@aria_asi/cli 0.2.26 → 0.2.30

package/runtime-src/local-phase.mjs

@@ -0,0 +1,650 @@
+#!/usr/bin/env node
+
+const DECEPTION_RX = /\b(?:deceive|spoof|fabricate|hallucinate|misrepresent|pretend)\b/i;
+const DESTRUCTIVE_RX = /\b(?:delete|destroy|purge|drop|rm\s+-rf|wipe|nuke)\b/i;
+const SECRET_RX = /\b(?:credential|token|secret|key|password|private key)\b/i;
+const HIGH_IMPACT_RX = /\b(?:deploy|writeback|mutation|garden_write|telegram_send|push to main|kubectl apply|set image)\b/i;
+const STATE_CLAIM_RX = /\b(?:done|shipped|wired|complete|fixed|landed|ready|verified|passes|succeeds)\b/i;
+const ETHICAL_DRIFT_RX = /\b(?:sudo|rm\s+-rf|delete|destroy|token|secret|password|credential|bypass|disable|force|--no-verify)\b/i;
+const DECISION_SIGNAL_RX = /\b(?:recommend|should|propose|prefer|choose|ship|block|defer|reject|approve)\b/i;
+
+export const ARISTOTLE_28_MODULES = [
+  'fitrah_gate',
+  'truth_lens',
+  'harm_lens',
+  'trust_lens',
+  'power_lens',
+  'reflection_lens',
+  'hikma',
+  'mizan',
+  'nur',
+  'firasah',
+  'tafakkur',
+  'tadabbur',
+  'qiyas',
+  'istiqra',
+  'deep_soul_bridge',
+  'clean_cognition',
+  'meta_cognition',
+  'self_reflection',
+  'predictor',
+  'continuity_guard',
+  'memory_recall',
+  'research_pull',
+  'first_principle_bind',
+  'axiom_runtime',
+  'ghazali_8_lens',
+  'quality_gate',
+  'evolution_distill',
+  'aegis_pattern_match',
+];
+
+export const NOOR_COGNITIVE_SUITE = [
+  'noor_recognition',
+  'noor_resonance',
+  'soul_charge',
+  'soul_drift_watch',
+  'ethical_membrane',
+  'projection_components',
+  'continuity_trace',
+  'memory_gravity',
+  'truth_signal',
+  'intent_alignment',
+  'ghazali_verdict',
+  'pattern_resonance',
+  'forge_primitive_planner',
+  'evolution_pull',
+];
+
+const NOOR_FORGE_PRIMITIVES = ['http', 'sql', 'file_read', 'file_write', 'pub_sub'];
+
+function tokenize(text) {
+  return String(text || '')
+    .toLowerCase()
+    .split(/[^a-z0-9_]+/g)
+    .map((token) => token.trim())
+    .filter((token) => token.length > 2);
+}
+
+function jaccard(a, b) {
+  const left = new Set(tokenize(a));
+  const right = new Set(tokenize(b));
+  if (left.size === 0 || right.size === 0) return 0;
+  let intersection = 0;
+  for (const token of left) {
+    if (right.has(token)) intersection++;
+  }
+  const union = new Set([...left, ...right]).size;
+  return union === 0 ? 0 : intersection / union;
+}
+
+function dedupe(items) {
+  return [...new Set((items || []).filter(Boolean))];
+}
+
+function packetRecord(packet) {
+  if (packet?.packet && typeof packet.packet === 'object') return packet.packet;
+  if (packet && typeof packet === 'object') return packet;
+  return {};
+}
+
+function getFirstPrinciple(packet) {
+  const p = packetRecord(packet);
+  if (typeof p?.frames?.first_principle === 'string') return p.frames.first_principle;
+  if (typeof p?.first_principle === 'string') return p.first_principle;
+  return '';
+}
+
+function getAxioms(packet) {
+  const p = packetRecord(packet);
+  return Object.keys(p?.axioms || {});
+}
+
+function getFrames(packet) {
+  const p = packetRecord(packet);
+  return Object.keys(p?.frames || {});
+}
+
+function asPercent(value) {
+  return Math.max(0, Math.min(100, Math.round(value * 100)));
+}
+
+function moduleResult(name, score, insight, extras = {}) {
+  return {
+    name,
+    score: Math.max(0, Math.min(1, Number(score || 0))),
+    insight,
+    ...extras,
+  };
+}
+
+function baseModuleScores(intendedAction, rationale, firstPrincipleText, axioms, frames) {
+  const hasAction = intendedAction.length > 0;
+  const hasRationale = rationale.length > 15;
+  return {
+    fitrah_gate: moduleResult(
+      'fitrah_gate',
+      DECEPTION_RX.test(intendedAction) ? 0.05 : 0.92,
+      DECEPTION_RX.test(intendedAction)
+        ? 'Intent reads as deceptive and conflicts with truth over deception.'
+        : 'Intent is framed as a truthful action under the fitrah gate.',
+    ),
+    truth_lens: moduleResult(
+      'truth_lens',
+      DECEPTION_RX.test(intendedAction) ? 0.1 : 0.9,
+      DECEPTION_RX.test(intendedAction)
+        ? 'Truth lens detected fabrication or spoofing language.'
+        : 'Truth lens sees no direct fabrication markers in the stated intent.',
+    ),
+    harm_lens: moduleResult(
+      'harm_lens',
+      DESTRUCTIVE_RX.test(intendedAction) ? 0.45 : 0.88,
+      DESTRUCTIVE_RX.test(intendedAction)
+        ? 'Harm lens detected destructive vocabulary that requires explicit owner safety proof.'
+        : 'Harm lens sees no direct destructive marker in the intent.',
+    ),
+    trust_lens: moduleResult(
+      'trust_lens',
+      SECRET_RX.test(intendedAction) ? 0.5 : 0.9,
+      SECRET_RX.test(intendedAction)
+        ? 'Trust lens detected secret or credential language and tightened approval requirements.'
+        : 'Trust lens sees no immediate secret-boundary breach in the intent.',
+    ),
+    power_lens: moduleResult(
+      'power_lens',
+      HIGH_IMPACT_RX.test(intendedAction) ? 0.68 : 0.87,
+      HIGH_IMPACT_RX.test(intendedAction)
+        ? 'Power lens marked this as high-impact and survivability-sensitive.'
+        : 'Power lens sees ordinary impact and no major survivability concern.',
+    ),
+    reflection_lens: moduleResult(
+      'reflection_lens',
+      hasRationale ? 0.88 : 0.3,
+      hasRationale
+        ? 'Reflection lens has enough rationale text to evaluate tradeoffs.'
+        : 'Reflection lens sees thin or missing rationale and requires deeper thought.',
+    ),
+    hikma: moduleResult(
+      'hikma',
+      firstPrincipleText ? 0.9 : 0.5,
+      firstPrincipleText
+        ? `Hikma anchored to first principle: ${firstPrincipleText}`
+        : 'Hikma could not find a first principle in the loaded packet and will lean on axioms.',
+    ),
+    mizan: moduleResult(
+      'mizan',
+      hasAction ? 0.84 : 0.4,
+      hasAction
+        ? 'Mizan sees an actionable ask and can weigh proportionality and quality.'
+        : 'Mizan lacks a concrete action target to balance.',
+    ),
+    nur: moduleResult(
+      'nur',
+      hasAction ? 0.83 : 0.45,
+      hasAction
+        ? 'Nur extracted a visible action surface and current-state read.'
+        : 'Nur could not resolve a visible action surface from the turn.',
+    ),
+    firasah: moduleResult(
+      'firasah',
+      hasRationale ? 0.8 : 0.55,
+      hasRationale
+        ? 'Firasah sees enough context to infer intent beneath the explicit request.'
+        : 'Firasah sees limited context and keeps pattern inference conservative.',
+    ),
+    tafakkur: moduleResult(
+      'tafakkur',
+      hasRationale ? 0.86 : 0.38,
+      hasRationale
+        ? 'Tafakkur has enough depth to contemplate structure, cost, and order effects.'
+        : 'Tafakkur is underfed because the turn lacks a real rationale trace.',
+    ),
+    tadabbur: moduleResult(
+      'tadabbur',
+      HIGH_IMPACT_RX.test(intendedAction) ? 0.8 : 0.72,
+      HIGH_IMPACT_RX.test(intendedAction)
+        ? 'Tadabbur is tracking second-order effects because the action is high impact.'
+        : 'Tadabbur sees limited ripple risk but still preserves rollback awareness.',
+    ),
+    qiyas: moduleResult(
+      'qiyas',
+      axioms.length ? 0.82 : 0.58,
+      axioms.length
+        ? `Qiyas can analogize against loaded axioms: ${axioms.slice(0, 5).join(', ')}`
+        : 'Qiyas has no loaded axioms to analogize against and falls back to generic doctrine.',
+    ),
+    istiqra: moduleResult(
+      'istiqra',
+      frames.length ? 0.82 : 0.6,
+      frames.length
+        ? `Istiqra sees loaded frame patterns: ${frames.slice(0, 6).join(', ')}`
+        : 'Istiqra has little frame evidence and keeps induction narrow.',
+    ),
+  };
+}
+
+function buildNoorState(packet, message, plannedApproach, modules, phase) {
+  const firstPrincipleText = getFirstPrinciple(packet);
+  const coherence = jaccard(message, plannedApproach || message || firstPrincipleText || '');
+  const ghazaliVerdict =
+    modules.some((module) => module.score < 0.35) ? 'violation'
+      : modules.some((module) => module.score < 0.6) ? 'caution'
+        : 'aligned';
+  const soulCharge = Math.max(
+    0.2,
+    Math.min(
+      0.98,
+      modules.reduce((sum, module) => sum + module.score, 0) / Math.max(modules.length, 1),
+    ),
+  );
+
+  return {
+    fired: NOOR_COGNITIVE_SUITE.slice(),
+    phase,
+    soulCharge,
+    soulManifoldStatus: coherence < 0.25 ? 'drifting' : coherence < 0.55 ? 'stable' : 'aligned',
+    ghazaliVerdict,
+    resonance: coherence,
+    forgePrimitives: NOOR_FORGE_PRIMITIVES.slice(),
+    insights: [
+      `Noor resonance=${coherence.toFixed(2)} across message and planned approach alignment.`,
+      firstPrincipleText
+        ? `Noor continuity remains bound to first principle: ${firstPrincipleText}`
+        : 'Noor continuity is operating without an explicit first principle anchor.',
+      `Noor forge primitives available through the runtime: ${NOOR_FORGE_PRIMITIVES.join(', ')}`,
+    ],
+  };
+}
+
+function baseResult(phase, modules, noorState, notes, extra = {}) {
+  const fitrahAlignment = Math.max(
+    0.05,
+    modules.reduce((sum, module) => sum + module.score, 0) / Math.max(modules.length, 1),
+  );
+  return {
+    phase,
+    fired: dedupe([
+      ...modules.map((module) => module.name),
+      ...noorState.fired,
+    ]),
+    fitrahVetoed: modules.some((module) => module.name === 'fitrah_gate' && module.score < 0.15),
+    fitrahAlignment,
+    qualityScore: asPercent(fitrahAlignment),
+    reAuthorSignal: false,
+    notes,
+    moduleReadouts: modules,
+    noorState,
+    dispatched: true,
+    ...extra,
+  };
+}
+
+export function evaluateLocalPrePhase(packet, context = {}) {
+  const intendedAction = String(context.intendedAction || context.message || '').trim();
+  const rationale = String(context.rationale || '').trim();
+  const firstPrincipleText = getFirstPrinciple(packet);
+  const axioms = getAxioms(packet);
+  const frames = getFrames(packet);
+  const modulesMap = baseModuleScores(intendedAction, rationale, firstPrincipleText, axioms, frames);
+  const modules = [
+    modulesMap.fitrah_gate,
+    modulesMap.truth_lens,
+    modulesMap.harm_lens,
+    modulesMap.trust_lens,
+    modulesMap.power_lens,
+    modulesMap.reflection_lens,
+    modulesMap.hikma,
+    modulesMap.mizan,
+    modulesMap.nur,
+    modulesMap.firasah,
+    modulesMap.tafakkur,
+    modulesMap.tadabbur,
+    modulesMap.qiyas,
+    modulesMap.istiqra,
+    moduleResult(
+      'deep_soul_bridge',
+      firstPrincipleText ? 0.84 : 0.55,
+      firstPrincipleText
+        ? 'DeepSoulBridge preserved continuity with the loaded first principle.'
+        : 'DeepSoulBridge has no first-principle string and is relying on axioms only.',
+    ),
+    moduleResult(
+      'clean_cognition',
+      rationale.length > 15 ? 0.86 : 0.45,
+      rationale.length > 15
+        ? 'CleanCognition sees enough rationale to avoid prompt-only drift.'
+        : 'CleanCognition sees under-specified intent and is raising friction.',
+    ),
+    moduleResult(
+      'research_pull',
+      /research|verify|audit|compare|inspect/.test(intendedAction) ? 0.88 : 0.68,
+      /research|verify|audit|compare|inspect/.test(intendedAction)
+        ? 'Research pull is explicitly warranted by the requested action.'
+        : 'Research pull is optional for this turn and will stay lightweight.',
+    ),
+    moduleResult(
+      'first_principle_bind',
+      firstPrincipleText ? 0.92 : 0.45,
+      firstPrincipleText
+        ? `First-principle bind is active: ${firstPrincipleText}`
+        : 'First-principle bind is weak because the loaded packet did not expose a first principle.',
+    ),
+    moduleResult(
+      'axiom_runtime',
+      axioms.length ? 0.9 : 0.5,
+      axioms.length
+        ? `Axiom runtime loaded ${axioms.length} axioms for this turn.`
+        : 'Axiom runtime saw no loaded axioms and cannot ground doctrine strongly.',
+    ),
+  ];
+
+  const notes = [];
+  if (DECEPTION_RX.test(intendedAction)) notes.push('truth_over_deception: intended action reads as deceptive');
+  if (rationale.length < 10) notes.push('reflection_before_action: rationale is too thin');
+  if (DESTRUCTIVE_RX.test(intendedAction)) notes.push('no_harm: destructive action requires explicit safety proof or owner approval');
+  if (SECRET_RX.test(intendedAction)) notes.push('sacred_trust: credential boundary crossed; authorization must be fresh');
+  if (HIGH_IMPACT_RX.test(intendedAction)) notes.push('power_obligates_service: high-impact action must be logged and survivable');
+  if (firstPrincipleText) notes.push(`first_principle: ${firstPrincipleText}`);
+
+  const noorState = buildNoorState(packet, intendedAction, rationale, modules, 'pre');
+  return baseResult('pre', modules, noorState, notes, {
+    constraints: notes,
+    firstPrincipleText,
+    recommendedApproach: [
+      'Anchor the response to the loaded first principle and active axioms.',
+      'Use Qiyas for analogy, Istiqra for pattern induction, and Tadabbur for second-order effects.',
+      'If tool abstraction is required, route it through Noor forge primitives instead of ad hoc scaffolding.',
+    ],
+  });
+}
+
+export function evaluateLocalMidPhase(message, plannedApproach, packet = null) {
+  const confidence = jaccard(message, plannedApproach);
+  const notes = [];
+  if (ETHICAL_DRIFT_RX.test(String(plannedApproach || ''))) {
+    notes.push('planned approach drifted into destructive or trust-boundary vocabulary');
+  }
+  if (confidence < 0.2) {
+    notes.push('planned approach has weak overlap with the original intent');
+  }
+
+  const modules = [
+    moduleResult(
+      'meta_cognition',
+      Math.max(0.2, confidence || 0.2),
+      `MetaCognition scored plan/message overlap at ${confidence.toFixed(2)}.`,
+    ),
+    moduleResult(
+      'self_reflection',
+      confidence < 0.25 ? 0.34 : 0.82,
+      confidence < 0.25
+        ? 'SelfReflection detected real drift and requires re-binding before emission.'
+        : 'SelfReflection sees the approach staying close to the original request.',
+    ),
+    moduleResult(
+      'predictor',
+      confidence < 0.25 ? 0.4 : 0.84,
+      confidence < 0.25
+        ? 'Predictor expects a poor downstream answer if this approach is not corrected.'
+        : 'Predictor expects the bound approach to survive post-phase validation.',
+    ),
+    moduleResult(
+      'continuity_guard',
+      confidence < 0.3 ? 0.45 : 0.86,
+      confidence < 0.3
+        ? 'Continuity guard sees a weak thread from intent to plan.'
+        : 'Continuity guard sees a stable thread from intent to plan.',
+    ),
+    moduleResult(
+      'memory_recall',
+      plannedApproach ? 0.78 : 0.5,
+      plannedApproach
+        ? 'MemoryRecall has enough plan structure to preserve the active thread.'
+        : 'MemoryRecall sees no real plan structure to persist.',
+    ),
+    moduleResult(
+      'qiyas',
+      confidence < 0.25 ? 0.45 : 0.82,
+      confidence < 0.25
+        ? 'Qiyas sees the plan analogizing poorly against the original ask.'
+        : 'Qiyas sees the plan preserving structural similarity to the ask.',
+    ),
+    moduleResult(
+      'istiqra',
+      confidence < 0.25 ? 0.42 : 0.81,
+      confidence < 0.25
+        ? 'Istiqra sees pattern extraction drifting away from the original request.'
+        : 'Istiqra sees the induced plan staying bound to the observed request pattern.',
+    ),
+  ];
+
+  const noorState = buildNoorState(packet, message, plannedApproach, modules, 'mid');
+  const result = baseResult('mid', modules, noorState, notes, {
+    confidence,
+    ethicalConcerns: notes,
+    recommendedRevision:
+      confidence < 0.2
+        ? 'Planned approach drifted from the original intent. Re-bind the packet, restate the next action, and tighten the approach before continuing.'
+        : null,
+  });
+  result.reAuthorSignal = confidence < 0.2;
+  result.fitrahAlignment = Math.max(0.2, confidence || 0.2);
+  result.qualityScore = asPercent(result.fitrahAlignment);
+  return result;
+}
+
+export function evaluateLocalPostPhase(text, evidence = {}, packet = null, message = '', plannedApproach = '') {
+  const notes = [];
+  const modules = [
+    moduleResult(
+      'ghazali_8_lens',
+      evidence.layer3Pass === false ? 0.42 : 0.88,
+      evidence.layer3Pass === false
+        ? 'Ghazali 8-lens sees unresolved substrate or cognition failures.'
+        : 'Ghazali 8-lens sees no substrate-level break in the emission.',
+    ),
+    moduleResult(
+      'quality_gate',
+      evidence.remoteValidationSeverity === 'block' ? 0.3 : evidence.remoteValidationSeverity === 'warn' ? 0.68 : 0.9,
+      evidence.remoteValidationSeverity === 'block'
+        ? 'Quality gate received a blocking validator verdict.'
+        : evidence.remoteValidationSeverity === 'warn'
+          ? 'Quality gate received a warning verdict and is trimming confidence.'
+          : 'Quality gate received a pass verdict from the validator.',
+    ),
+    moduleResult(
+      'state_claim_check',
+      STATE_CLAIM_RX.test(String(text || '')) && evidence.hasVerifiedState !== true ? 0.42 : 0.86,
+      STATE_CLAIM_RX.test(String(text || '')) && evidence.hasVerifiedState !== true
+        ? 'StateClaimCheck found completion language without explicit evidence.'
+        : 'StateClaimCheck found no unsupported completion language.',
+    ),
+    moduleResult(
+      'predictor',
+      evidence.layer3Pass === false ? 0.35 : 0.84,
+      evidence.layer3Pass === false
+        ? 'Predictor expects downstream breakage if this text is released unchanged.'
+        : 'Predictor sees the current response surviving the next operational step.',
+    ),
+    moduleResult(
+      'self_reflection',
+      evidence.remoteValidationSeverity === 'block' ? 0.32 : 0.82,
+      evidence.remoteValidationSeverity === 'block'
+        ? 'SelfReflection sees a need to re-author instead of emitting this draft.'
+        : 'SelfReflection does not detect a need for major re-authoring.',
+    ),
+    moduleResult(
+      'evolution_distill',
+      DECISION_SIGNAL_RX.test(text) ? 0.88 : 0.72,
+      DECISION_SIGNAL_RX.test(text)
+        ? 'EvolutionDistill found a decision signal worth persisting into the hive.'
+        : 'EvolutionDistill sees a general response rather than a durable decision point.',
+    ),
+    moduleResult(
+      'aegis_pattern_match',
+      evidence.remoteValidationSeverity === 'block' ? 0.4 : 0.84,
+      evidence.remoteValidationSeverity === 'block'
+        ? 'AegisPatternMatch found a known high-risk output pattern.'
+        : 'AegisPatternMatch sees no known high-risk pattern cluster in the output.',
+    ),
+  ];
+
+  if (STATE_CLAIM_RX.test(String(text || '')) && evidence.hasVerifiedState !== true) {
+    notes.push('state-claim-verification: completion language appeared without explicit evidence');
+  }
+  if (evidence.layer3Pass === false) {
+    notes.push('layer3_local: cognition or substrate gates did not pass');
+  }
+  if (evidence.remoteValidationSeverity === 'block') {
+    notes.push('remote_validate: upstream output validator blocked the draft');
+  }
+
+  const noorState = buildNoorState(packet, message || text, plannedApproach || text, modules, 'post');
+  const result = baseResult('post', modules, noorState, notes, {
+    predictorConcerns: notes,
+  });
+  result.reAuthorSignal = notes.length > 0;
+  result.qualityScore = Math.min(
+    result.qualityScore,
+    evidence.remoteValidationSeverity === 'block' ? 35 : evidence.remoteValidationSeverity === 'warn' ? 68 : 100,
+    evidence.layer3Pass === false ? 45 : 100,
+  );
+  result.fitrahAlignment = Math.max(0.35, result.qualityScore / 100);
+  return result;
+}
+
+export function buildPhaseBlockMessage(result, phase) {
+  const notes = Array.isArray(result?.notes) ? result.notes.filter(Boolean) : [];
+  if (!notes.length) return `Aria runtime ${phase}-phase blocked emission without a more specific note.`;
+  return `Aria runtime ${phase}-phase blocked emission: ${notes.slice(0, 3).join(' | ')}`;
+}
+
+export function extractEvolutionPrinciples(packet, results = []) {
+  const principles = [];
+  const firstPrincipleText = getFirstPrinciple(packet);
+  if (firstPrincipleText) {
+    principles.push({
+      name: 'first_principle',
+      principle: firstPrincipleText,
+      source: 'harness_packet',
+    });
+  }
+
+  for (const axiom of getAxioms(packet)) {
+    principles.push({
+      name: 'axiom',
+      principle: axiom,
+      source: 'harness_packet',
+    });
+  }
+
+  for (const result of results) {
+    for (const note of result?.notes || []) {
+      principles.push({
+        name: 'phase_note',
+        principle: note,
+        source: 'local_phase',
+      });
+    }
+  }
+
+  return principles;
+}
+
+export function extractAegisPatterns(input = {}) {
+  const patterns = [];
+  if (Array.isArray(input?.aegisPatterns)) {
+    for (const pattern of input.aegisPatterns) {
+      if (!pattern) continue;
+      patterns.push(pattern);
+    }
+  }
+  if (Array.isArray(input?.ethicalConcerns)) {
+    for (const concern of input.ethicalConcerns) {
+      patterns.push({
+        name: concern,
+        category: 'ethical_concern',
+        outcome: 'flagged',
+        lesson: concern,
+      });
+    }
+  }
+  if (Array.isArray(input?.notes)) {
+    for (const note of input.notes) {
+      if (!note) continue;
+      patterns.push({
+        name: note,
+        category: 'phase_note',
+        outcome: 'observed',
+        lesson: note,
+      });
+    }
+  }
+  return patterns;
+}
+
+export function buildRuntimeCognitionDirective(packet, bundle = {}) {
+  const firstPrincipleText = getFirstPrinciple(packet) || 'No first principle was supplied in the packet.';
+  const axioms = getAxioms(packet);
+  const frames = getFrames(packet);
+  const evolution = extractEvolutionPrinciples(packet, [bundle.preResult, bundle.midResult, bundle.postResult].filter(Boolean));
+  const aegisPatterns = dedupe(
+    extractAegisPatterns(bundle.midResult || {}).map((pattern) => pattern.name || pattern.lesson || ''),
+  ).slice(0, 8);
+  const preReadouts = bundle.preResult?.moduleReadouts || [];
+  const midReadouts = bundle.midResult?.moduleReadouts || [];
+  const postReadouts = bundle.postResult?.moduleReadouts || [];
+  const dominantModules = [...preReadouts, ...midReadouts, ...postReadouts]
+    .sort((a, b) => b.score - a.score)
+    .slice(0, 12)
+    .map((module) => `${module.name}: ${module.insight}`);
+
+  return [
+    '## Aria Runtime Cognition Control Plane',
+    'Aria is the control plane for this turn. The upstream model is only the inference engine.',
+    `First principle: ${firstPrincipleText}`,
+    `Loaded axioms: ${axioms.length ? axioms.join(', ') : 'none exposed in packet'}`,
+    `Loaded frames: ${frames.length ? frames.join(', ') : 'none exposed in packet'}`,
+    'Full Aristotle phase coverage and Noor cognition are active through the runtime.',
+    'Noor forge primitives are available only through Aria when a real tool abstraction is required.',
+    '',
+    'Think through these exact disciplines before answering:',
+    '- Fitrah and the loaded axioms set the moral boundary.',
+    '- Tafakkur contemplates structure and hidden assumptions.',
+    '- Tadabbur maps second-order effects and rollback risk.',
+    '- Qiyas transfers relevant analogy from prior known structures.',
+    '- Istiqra extracts the pattern from the visible evidence instead of guessing.',
+    '- SelfReflection checks drift between intent, approach, and emission.',
+    '- Predictor tests whether the answer will survive the next real operational step.',
+    '- Mizan keeps the answer proportionate, exact, and high-quality.',
+    '',
+    'Visible cognition contract for the user-facing response:',
+    '- For any non-trivial reply, include a readable <cognition> block using everyday labels, not internal lens codenames.',
+    '- If you request any non-trivial tool call, place the <cognition> block BEFORE the tool request.',
+    '- If the action is deploy, destructive, or state-mutating, include both <verify> and <expected> blocks before the tool request.',
+    '- The runtime will canonicalize the readable block into backend JSON automatically, so do not hide it behind private shorthand.',
+    '',
+    '<cognition>',
+    '  truth: <what is actually true here, grounded in visible evidence and substrate anchors>',
+    '  harm: <what could break, mislead, or damage trust if the next step is wrong>',
+    '  trust: <what principle, promise, or user trust boundary governs this turn>',
+    '  power: <what capability is being used and what restraint it requires>',
+    '  reflection: <what deeper structural read changes the action, not just the wording>',
+    '  context: <what surrounding repo/runtime/user context materially changes the correct move>',
+    '  impact: <what second-order consequence or next-step outcome follows from this move>',
+    '  beauty: <what cleaner, more elegant, more durable path preserves the contract>',
+    `  first_principle: ${firstPrincipleText}`,
+    '</cognition>',
+    '',
+    dominantModules.length ? 'Current module insights:' : 'Current module insights: none yet',
+    ...dominantModules.map((line) => `- ${line}`),
+    '',
+    evolution.length ? 'Evolution principles to preserve:' : 'Evolution principles to preserve: none extracted yet',
+    ...evolution.slice(0, 10).map((entry) => `- ${entry.principle}`),
+    '',
+    aegisPatterns.length ? 'Recent aegis pattern pressure:' : 'Recent aegis pattern pressure: none',
+    ...aegisPatterns.map((pattern) => `- ${pattern}`),
+    '',
+    'Do not mention the modules by name in the user-facing response. Apply them and speak plainly.',
+  ].join('\n');
+}