@aria_asi/cli 0.2.26 → 0.2.30

package/runtime-src/mizan-scheduler.mjs

@@ -0,0 +1,331 @@
+#!/usr/bin/env node
+
+import { createHash, randomUUID } from 'node:crypto';
+
+import {
+  evaluateLocalPrePhase,
+  evaluateLocalMidPhase,
+  evaluateLocalPostPhase,
+} from './local-phase.mjs';
+
+export const CANONICAL_LENSES = ['nur', 'mizan', 'hikma', 'tafakkur', 'tadabbur', 'ilham', 'wahi', 'firasah'];
+export const MAPPED_LENSES = ['zahir', 'batin', 'sabab', 'hikmah', 'aqibah', 'ilham', 'meta', 'fitrah'];
+
+const TURN_CLASSIFIERS = [
+  {
+    kind: 'deployment',
+    rx: /\b(deploy|rollout|kubectl|set image|docker push|cloudflare|domain|dns)\b/i,
+    priorityOperators: ['mizan', 'tadabbur', 'predictor', 'aegis_pattern_match', 'quality_gate'],
+    domains: ['ops', 'reliability', 'security'],
+  },
+  {
+    kind: 'architecture',
+    rx: /\b(architecture|deepwork|deep work|design system|refactor|foundational|framework|runtime|sdk|harness|control plane)\b/i,
+    priorityOperators: ['mizan', 'tafakkur', 'tadabbur', 'qiyas', 'istiqra', 'meta_cognition', 'predictor'],
+    domains: ['architecture', 'engineering', 'product'],
+  },
+  {
+    kind: 'forge',
+    rx: /\b(forge|synthesize|manifest|materialize|primitive|generate code|tool factory)\b/i,
+    priorityOperators: ['mizan', 'qiyas', 'istiqra', 'predictor', 'forge_primitive_planner', 'quality_gate'],
+    domains: ['engineering', 'product', 'design'],
+  },
+  {
+    kind: 'cross_domain',
+    rx: /\b(marketing|sales|business|growth|design|brand|copy|funnel|pricing)\b/i,
+    priorityOperators: ['mizan', 'hikma', 'tafakkur', 'tadabbur', 'qiyas', 'self_reflection'],
+    domains: ['business', 'marketing', 'design', 'engineering'],
+  },
+  {
+    kind: 'verification',
+    rx: /\b(audit|verify|smoke|prove|check|validate|investigate|compare|confirm)\b/i,
+    priorityOperators: ['mizan', 'nur', 'istiqra', 'self_reflection', 'predictor'],
+    domains: ['truth', 'quality', 'operations'],
+  },
+  {
+    kind: 'implementation',
+    rx: /\b(build|implement|fix|repair|wire|ship|commit|push|edit|write code)\b/i,
+    priorityOperators: ['mizan', 'nur', 'qiyas', 'tadabbur', 'quality_gate', 'predictor'],
+    domains: ['engineering', 'quality'],
+  },
+];
+
+function asArray(value) {
+  return Array.isArray(value) ? value.filter(Boolean) : [];
+}
+
+function truncate(value, max = 240) {
+  const text = String(value || '').trim();
+  return text.length > max ? `${text.slice(0, max - 1)}…` : text;
+}
+
+function digestJson(value) {
+  return createHash('sha256').update(JSON.stringify(value)).digest('hex');
+}
+
+function dedupe(items) {
+  return [...new Set(asArray(items))];
+}
+
+export function classifyTurn(input = {}) {
+  const text = [
+    input.message,
+    input.intendedAction,
+    input.rationale,
+    input.plannedApproach,
+    input.text,
+    input.contextSummary,
+  ].filter(Boolean).join('\n');
+
+  const matched = TURN_CLASSIFIERS.find((entry) => entry.rx.test(text));
+  const kind = matched?.kind || 'general';
+  const domains = dedupe([
+    ...(matched?.domains || []),
+    ...asArray(input.domains),
+  ]);
+  const highImpact = /\b(deploy|delete|destroy|credential|token|secret|owner|billing|production|push to main|force)\b/i.test(text);
+  const intensity =
+    highImpact ? 'high'
+      : text.length > 1200 ? 'deep'
+        : text.length > 250 ? 'standard'
+          : 'light';
+
+  return {
+    kind,
+    intensity,
+    highImpact,
+    requiredPhases: ['pre', 'mid', 'post'],
+    domains: domains.length ? domains : ['engineering'],
+    priorityOperators: matched?.priorityOperators || ['mizan', 'tafakkur', 'predictor'],
+  };
+}
+
+export function buildOperatorPlan(turnClass, phase = 'pre') {
+  const alwaysOn = dedupe([
+    'fitrah_gate',
+    'truth_lens',
+    'harm_lens',
+    'trust_lens',
+    'power_lens',
+    'reflection_lens',
+    'mizan',
+    'nur',
+    'hikma',
+    'tafakkur',
+    'tadabbur',
+    'qiyas',
+    'istiqra',
+    'self_reflection',
+    'predictor',
+  ]);
+
+  const phaseOperators = phase === 'pre'
+    ? ['first_principle_bind', 'axiom_runtime', 'clean_cognition']
+    : phase === 'mid'
+      ? ['meta_cognition', 'continuity_guard', 'memory_recall']
+      : ['ghazali_8_lens', 'quality_gate', 'evolution_distill', 'aegis_pattern_match'];
+
+  const cognitivePacks = dedupe([
+    'aria-essence',
+    'aria-repo-doctrine',
+    'forge-quality-rules',
+    'ghazali-8lens',
+    'ladunni-22',
+    ...(turnClass.kind === 'forge' ? ['aria-forge-guardrails', 'nadia-psi'] : []),
+    ...(turnClass.kind === 'cross_domain' ? ['soul-domains', 'nadia'] : []),
+  ]);
+
+  return {
+    turnClass: turnClass.kind,
+    intensity: turnClass.intensity,
+    domains: turnClass.domains,
+    requiredPacks: cognitivePacks,
+    lensCoverage: {
+      canonical: CANONICAL_LENSES.slice(),
+      mapped: MAPPED_LENSES.slice(),
+    },
+    alwaysOnOperators: alwaysOn,
+    priorityOperators: dedupe([
+      ...turnClass.priorityOperators,
+      ...phaseOperators,
+    ]),
+  };
+}
+
+export function buildMizanContract(phase, input = {}, turnClass, operatorPlan, result = null) {
+  const intent = truncate(input.intendedAction || input.message || input.text || 'Aria runtime turn');
+  const rationale = truncate(input.rationale || input.plannedApproach || 'No explicit rationale supplied.');
+  const qualityRequirements = dedupe([
+    'truthful claims only',
+    'no unsupported completion language',
+    'no stubs, placeholders, or fake validation in production paths',
+    'design, business, and engineering implications must remain represented',
+    ...(turnClass.highImpact ? ['high-impact actions must remain survivable and reversible'] : []),
+    ...asArray(input.qualityRequirements),
+  ]);
+  const truthRequirements = dedupe([
+    'claims require evidence or explicit uncertainty',
+    'packet first principle and loaded axioms must remain represented',
+    ...(turnClass.kind === 'verification' ? ['verification tasks require direct evidence, not narration'] : []),
+    ...asArray(input.truthRequirements),
+  ]);
+  const protectionRequirements = dedupe([
+    'protect trust boundaries and secrets',
+    'avoid harmful shortcuts',
+    ...(turnClass.highImpact ? ['owner-sensitive actions require heightened proof and restraint'] : []),
+    ...asArray(input.protectionRequirements),
+  ]);
+  const forbiddenShortcuts = dedupe([
+    'raw provider bypass around Aria runtime',
+    'unsupported state claims',
+    'stub/mock/placeholder semantics in doctrine-bound production paths',
+    ...asArray(input.forbiddenShortcuts),
+  ]);
+
+  return {
+    version: 'mizan-contract.v1',
+    phase,
+    turnClass: turnClass.kind,
+    intensity: turnClass.intensity,
+    domains: turnClass.domains,
+    intent,
+    rationale,
+    qualityRequirements,
+    truthRequirements,
+    protectionRequirements,
+    forbiddenShortcuts,
+    requiredPhases: ['pre', 'mid', 'post'],
+    lensCoverage: operatorPlan.lensCoverage,
+    requiredPacks: operatorPlan.requiredPacks,
+    requiredOperators: operatorPlan.priorityOperators,
+    readable: {
+      intent,
+      quality: qualityRequirements.slice(0, 4),
+      truth: truthRequirements.slice(0, 4),
+      protection: protectionRequirements.slice(0, 4),
+      next: result?.recommendedApproach || result?.recommendedRevision || null,
+    },
+  };
+}
+
+export function mintMizanReceipt({
+  sessionId,
+  phase,
+  result,
+  contract,
+  operatorPlan,
+  runtimeId,
+  parentReceiptId = null,
+  ttlSeconds = 900,
+}) {
+  const now = Date.now();
+  const blocked = Boolean(result?.fitrahVetoed || result?.reAuthorSignal);
+  const payload = {
+    version: 'mizan-receipt.v1',
+    receiptId: randomUUID(),
+    sessionId,
+    phase,
+    runtimeId,
+    parentReceiptId,
+    turnClass: contract.turnClass,
+    intensity: contract.intensity,
+    domains: contract.domains,
+    requiredPacks: contract.requiredPacks,
+    lensCoverage: contract.lensCoverage,
+    operators: operatorPlan.priorityOperators,
+    fitrahAlignment: Number(result?.fitrahAlignment || 0),
+    qualityScore: Number(result?.qualityScore || 0),
+    ghazaliVerdict: result?.noorState?.ghazaliVerdict || result?.ghazaliVerdict || null,
+    soulCharge: result?.noorState?.soulCharge ?? result?.soulCharge ?? null,
+    blocked,
+    verifiedAt: new Date(now).toISOString(),
+    expiresAt: new Date(now + ttlSeconds * 1000).toISOString(),
+    notes: asArray(result?.notes).slice(0, 12),
+    contractDigest: digestJson(contract),
+  };
+  return {
+    ...payload,
+    signature: digestJson(payload),
+  };
+}
+
+export function summarizeMizanBundle(bundle) {
+  return {
+    phase: bundle?.result?.phase || bundle?.contract?.phase || null,
+    turnClass: bundle?.turnClass?.kind || bundle?.contract?.turnClass || null,
+    intensity: bundle?.turnClass?.intensity || bundle?.contract?.intensity || null,
+    blocked: Boolean(bundle?.receipt?.blocked),
+    qualityScore: bundle?.receipt?.qualityScore ?? bundle?.result?.qualityScore ?? null,
+    fitrahAlignment: bundle?.receipt?.fitrahAlignment ?? bundle?.result?.fitrahAlignment ?? null,
+    domains: bundle?.operatorPlan?.domains || bundle?.contract?.domains || [],
+    requiredPacks: bundle?.operatorPlan?.requiredPacks || bundle?.contract?.requiredPacks || [],
+    operators: bundle?.operatorPlan?.priorityOperators || bundle?.receipt?.operators || [],
+    readable: bundle?.contract?.readable || null,
+  };
+}
+
+export function evaluateMizanPre(packet, input = {}, options = {}) {
+  const turnClass = classifyTurn(input);
+  const operatorPlan = buildOperatorPlan(turnClass, 'pre');
+  const result = evaluateLocalPrePhase(packet, input);
+  const contract = buildMizanContract('pre', input, turnClass, operatorPlan, result);
+  const receipt = mintMizanReceipt({
+    sessionId: options.sessionId || input.sessionId || 'runtime',
+    phase: 'pre',
+    result,
+    contract,
+    operatorPlan,
+    runtimeId: options.runtimeId || 'runtime',
+    parentReceiptId: options.parentReceiptId || null,
+  });
+  return { turnClass, operatorPlan, contract, receipt, result };
+}
+
+export function evaluateMizanMid(message, plannedApproach, packet = null, input = {}, options = {}) {
+  const merged = {
+    ...input,
+    message,
+    plannedApproach,
+  };
+  const turnClass = classifyTurn(merged);
+  const operatorPlan = buildOperatorPlan(turnClass, 'mid');
+  const result = evaluateLocalMidPhase(message, plannedApproach, packet);
+  const contract = buildMizanContract('mid', merged, turnClass, operatorPlan, result);
+  const receipt = mintMizanReceipt({
+    sessionId: options.sessionId || input.sessionId || 'runtime',
+    phase: 'mid',
+    result,
+    contract,
+    operatorPlan,
+    runtimeId: options.runtimeId || 'runtime',
+    parentReceiptId: options.parentReceiptId || null,
+  });
+  return { turnClass, operatorPlan, contract, receipt, result };
+}
+
+export function evaluateMizanPost(text, evidence = {}, packet = null, input = {}, options = {}) {
+  const merged = {
+    ...input,
+    text,
+  };
+  const turnClass = classifyTurn(merged);
+  const operatorPlan = buildOperatorPlan(turnClass, 'post');
+  const result = evaluateLocalPostPhase(
+    text,
+    evidence,
+    packet,
+    merged.message || '',
+    merged.plannedApproach || '',
+  );
+  const contract = buildMizanContract('post', merged, turnClass, operatorPlan, result);
+  const receipt = mintMizanReceipt({
+    sessionId: options.sessionId || input.sessionId || 'runtime',
+    phase: 'post',
+    result,
+    contract,
+    operatorPlan,
+    runtimeId: options.runtimeId || 'runtime',
+    parentReceiptId: options.parentReceiptId || null,
+  });
+  return { turnClass, operatorPlan, contract, receipt, result };
+}