@aria_asi/cli 0.2.39 → 0.2.41

package/scripts/qiyas-tadabbur-model-matrix.mjs

@@ -0,0 +1,970 @@
+#!/usr/bin/env node
+import { createHash } from 'node:crypto';
+import { spawnSync } from 'node:child_process';
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  statSync,
+  writeFileSync,
+} from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+const repoRoot = process.cwd();
+const runId = new Date().toISOString().replace(/[:.]/g, '-');
+const outputRoot = path.join(repoRoot, 'artifacts', 'qiyas-tadabbur-model-matrix', runId);
+const outputsDir = path.join(outputRoot, 'outputs');
+const qiyasPerspectives = [
+  'Owner-Hamza-tomorrow',
+  'operator-client',
+  'investor',
+  'LLM-consumer',
+  'human-end-user',
+  'skeptic',
+  'compliance',
+  'engineering-quality',
+  'cognitive-load',
+  'scale',
+  'Islamic-scholar',
+  'clinical-scholar',
+  'red-team-attacker',
+  '1-week-future-self',
+  '1-year-future-self',
+];
+const tadabburStages = [
+  'EMBED',
+  'EXCAVATE',
+  'ROOT TRACE',
+  'MULTI-LENS',
+  'PATTERN',
+  'CONSEQUENCE',
+  'DWELLING',
+  'COLLAPSE',
+  'PRINCIPLE',
+  'INVERSION',
+  'PERSONAL',
+  'VOICE',
+];
+const relevanceRx = /\b(qiyas|tadabbur|taddabur|fire skills|skills active|runtime|runtimes|autofire|first class|quality|gates|hook|cognition|substrate|kernel|qa|compare|model)\b/i;
+
+function ensureDir(dir) {
+  mkdirSync(dir, { recursive: true, mode: 0o755 });
+}
+
+function sha256(value) {
+  return createHash('sha256').update(String(value ?? '')).digest('hex');
+}
+
+function redactText(value) {
+  return String(value ?? '')
+    .replace(/sk-[^"\s,}\]]{8,}/g, 'sk-[REDACTED]')
+    .replace(/Bearer [^"\s,}\]]{8,}/g, 'Bearer [REDACTED]');
+}
+
+function redactRequest(value) {
+  if (Array.isArray(value)) return value.map(redactRequest);
+  if (typeof value === 'string') return redactText(value);
+  if (!value || typeof value !== 'object') return value;
+  return Object.fromEntries(Object.entries(value).map(([key, child]) => {
+    if (/api[_-]?key|authorization|bearer|secret|token|password/i.test(key) && typeof child !== 'boolean') return [key, '[REDACTED]'];
+    return [key, redactRequest(child)];
+  }));
+}
+
+function writeJsonArtifact(filePath, value) {
+  writeFileSync(filePath, JSON.stringify(redactRequest(value), null, 2) + '\n');
+}
+
+function asRecord(value) {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+
+function completionUsageDetails(data = {}) {
+  const usage = asRecord(data.usage);
+  const completionDetails = asRecord(usage.completion_tokens_details || usage.completionTokensDetails);
+  const completionTokens = Number(usage.completion_tokens ?? usage.completionTokens ?? 0);
+  const reasoningTokens = Number(completionDetails.reasoning_tokens ?? completionDetails.reasoningTokens ?? 0);
+  return {
+    promptTokens: Number(usage.prompt_tokens ?? usage.promptTokens ?? 0),
+    completionTokens,
+    totalTokens: Number(usage.total_tokens ?? usage.totalTokens ?? 0),
+    reasoningTokens,
+    allCompletionTokensSpentOnReasoning: completionTokens > 0 && reasoningTokens >= completionTokens,
+  };
+}
+
+function argValue(name, fallback = '') {
+  const prefix = `--${name}=`;
+  const raw = process.argv.find((arg) => arg.startsWith(prefix));
+  return raw ? raw.slice(prefix.length) : process.env[`ARIA_QT_${name.replaceAll('-', '_').toUpperCase()}`] || fallback;
+}
+
+function argNumber(name, fallback, { min = 1, max = Number.MAX_SAFE_INTEGER } = {}) {
+  const value = Number(argValue(name, String(fallback)));
+  return Math.min(max, Math.max(min, Number.isFinite(value) ? value : fallback));
+}
+
+async function mapConcurrent(items, concurrency, worker) {
+  const results = new Array(items.length);
+  let next = 0;
+  const workers = Array.from({ length: Math.min(concurrency, items.length) }, async () => {
+    while (next < items.length) {
+      const index = next;
+      next += 1;
+      results[index] = await worker(items[index], index);
+    }
+  });
+  await Promise.all(workers);
+  return results;
+}
+
+function walkFiles(root, predicate, maxFiles = 5000) {
+  const out = [];
+  function visit(dir) {
+    if (out.length >= maxFiles) return;
+    let entries = [];
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory()) visit(full);
+      else if (predicate(full)) out.push(full);
+      if (out.length >= maxFiles) return;
+    }
+  }
+  if (existsSync(root)) visit(root);
+  return out;
+}
+
+function recentJsonl(root, limit) {
+  return walkFiles(root, (file) => file.endsWith('.jsonl'), 12000)
+    .map((file) => {
+      try {
+        return { file, mtimeMs: statSync(file).mtimeMs };
+      } catch {
+        return null;
+      }
+    })
+    .filter(Boolean)
+    .sort((a, b) => b.mtimeMs - a.mtimeMs)
+    .slice(0, limit)
+    .map((entry) => entry.file);
+}
+
+function textFromContent(content) {
+  if (typeof content === 'string') return content;
+  if (!Array.isArray(content)) return '';
+  return content
+    .filter((part) => part && (part.type === 'text' || part.type === 'input_text' || part.type === 'output_text'))
+    .map((part) => part.text || '')
+    .join('\n')
+    .trim();
+}
+
+function readJsonl(file) {
+  try {
+    return readFileSync(file, 'utf8')
+      .split('\n')
+      .filter(Boolean)
+      .map((line) => {
+        try {
+          return JSON.parse(line);
+        } catch {
+          return null;
+        }
+      })
+      .filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+function extractCodexPairs(file) {
+  const rows = readJsonl(file);
+  let model = 'codex-observed';
+  const pairs = [];
+  let pendingUser = null;
+  for (const row of rows) {
+    if (row.type === 'session_meta') model = row.payload?.model || model;
+    const item = row.type === 'response_item' ? row.payload : null;
+    if (!item || item.type !== 'message') continue;
+    const role = item.role;
+    if (role === 'user') {
+      const text = textFromContent(item.content);
+      if (text && relevanceRx.test(text)) pendingUser = text;
+    } else if (role === 'assistant' && pendingUser) {
+      const text = textFromContent(item.content);
+      if (text) {
+        pairs.push({ source: 'codex', model, file, prompt: pendingUser, observedAnswer: text });
+        pendingUser = null;
+      }
+    }
+  }
+  return pairs;
+}
+
+function extractClaudePairs(file) {
+  const rows = readJsonl(file);
+  const pairs = [];
+  let pendingUser = null;
+  for (const row of rows) {
+    if (row.type !== 'user' && row.type !== 'assistant') continue;
+    const content = row.message?.content;
+    if (row.type === 'user') {
+      const text = textFromContent(content);
+      if (text && relevanceRx.test(text)) pendingUser = text;
+    } else if (row.type === 'assistant' && pendingUser) {
+      const text = textFromContent(content);
+      if (text) {
+        pairs.push({ source: 'claude', model: row.message?.model || 'claude-observed', file, prompt: pendingUser, observedAnswer: text });
+        pendingUser = null;
+      }
+    }
+  }
+  return pairs;
+}
+
+function collectPromptPairs({ sessionLimit, pairLimit, maxPromptChars }) {
+  const codexRoot = path.join(os.homedir(), '.codex', 'sessions');
+  const claudeRoot = path.join(os.homedir(), '.claude', 'projects');
+  const codexCandidates = recentJsonl(codexRoot, sessionLimit).flatMap(extractCodexPairs);
+  const claudeCandidates = recentJsonl(claudeRoot, sessionLimit).flatMap(extractClaudePairs);
+  const candidates = [...codexCandidates, ...claudeCandidates];
+  const seen = new Set();
+  const filtered = [];
+  for (const candidate of candidates) {
+    const prompt = String(candidate.prompt || '').replace(/\s+/g, ' ').trim();
+    if (prompt.length < 40 || prompt.length > maxPromptChars) continue;
+    const key = sha256(prompt);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    filtered.push({ ...candidate, prompt, promptSha256: key });
+  }
+  filtered.sort((a, b) => promptWeight(b.prompt) - promptWeight(a.prompt));
+  const balanced = [];
+  const perSourceFloor = Math.max(1, Math.floor(pairLimit / 3));
+  for (const source of ['codex', 'claude']) {
+    const sourceRows = filtered.filter((row) => row.source === source).slice(0, perSourceFloor);
+    for (const row of sourceRows) {
+      if (!balanced.find((existing) => existing.promptSha256 === row.promptSha256)) balanced.push(row);
+    }
+  }
+  for (const row of filtered) {
+    if (balanced.length >= pairLimit) break;
+    if (!balanced.find((existing) => existing.promptSha256 === row.promptSha256)) balanced.push(row);
+  }
+  return balanced.slice(0, pairLimit);
+}
+
+function promptWeight(text) {
+  const source = String(text || '').toLowerCase();
+  return [
+    ['qiyas', 8],
+    ['tadabbur', 8],
+    ['first class', 5],
+    ['autofire', 5],
+    ['runtime', 3],
+    ['skills', 3],
+    ['quality', 3],
+    ['compare', 3],
+    ['model', 2],
+  ].reduce((score, [term, weight]) => score + (source.includes(term) ? weight : 0), 0);
+}
+
+function providerApiKey(provider) {
+  if (provider === 'deepseek') return process.env.DEEPSEEK_API_KEY || process.env.ARIA_DEEPSEEK_API_KEY || '';
+  if (provider === 'xai') return process.env.XAI_API_KEY || process.env.GROK_API_KEY || '';
+  if (provider === 'openai') return process.env.OPENAI_API_KEY || '';
+  return '';
+}
+
+function providerUrl(provider) {
+  if (provider === 'deepseek') return 'https://api.deepseek.com/v1/chat/completions';
+  if (provider === 'xai') return 'https://api.x.ai/v1/chat/completions';
+  if (provider === 'openai') return 'https://api.openai.com/v1/chat/completions';
+  throw new Error(`unsupported provider: ${provider}`);
+}
+
+function parseModels() {
+  const raw = argValue('models', 'deepseek:deepseek-v4-flash,deepseek:deepseek-v4-pro,xai:grok-4.3,openai:gpt-5.5,openai:gpt-5.3-codex');
+  return raw.split(',')
+    .map((item) => item.trim())
+    .filter(Boolean)
+    .map((item) => {
+      const [provider, model] = item.split(':');
+      return { provider, model, id: `${provider}:${model}`, apiKeyPresent: Boolean(providerApiKey(provider)) };
+    });
+}
+
+function directSystemPrompt() {
+  return [
+    'You are a senior engineering and cognition evaluator.',
+    'Answer the user prompt directly.',
+    'Use full Qiyas-15 and full Tadabbur-12 as operative reasoning, but keep an owner-readable executive answer first.',
+    'Include enough structure that a deterministic grader can see whether the 15 Qiyas perspectives and 12 Tadabbur stages were actually covered.',
+    'Do not claim proof that is not present. Name a concrete next action and a measurable verification predicate.',
+  ].join(' ');
+}
+
+function matrixUserPrompt(prompt) {
+  return [
+    'Use the user prompt below as the exact task substrate.',
+    'Produce a full Qiyas and full Tadabbur quality answer that would help the owner decide what to do next.',
+    'Do not ask what to do next if a best next action can be named from the prompt.',
+    '',
+    'USER PROMPT:',
+    prompt,
+  ].join('\n');
+}
+
+async function callChatModel(modelSpec, prompt, index) {
+  if (!modelSpec.apiKeyPresent) {
+    return {
+      ok: false,
+      skipped: true,
+      reason: `missing API key for ${modelSpec.provider}`,
+      text: '',
+      durationMs: 0,
+      usage: null,
+    };
+  }
+  const started = Date.now();
+  const maxTokens = argNumber('max-tokens', 1800, { min: 400, max: 6000 });
+  const attempts = modelSpec.provider === 'deepseek' ? 2 : 1;
+  const blanks = [];
+  const requestAttempts = [];
+  for (let attempt = 1; attempt <= attempts; attempt += 1) {
+    const visibleAnswerSuffix = attempt > 1
+      ? '\n\nReturn a visible final answer in message.content. Do not spend the entire completion budget on hidden reasoning.'
+      : '';
+    const body = {
+      model: modelSpec.model,
+      messages: [
+        { role: 'system', content: directSystemPrompt() + visibleAnswerSuffix },
+        { role: 'user', content: matrixUserPrompt(prompt) },
+      ],
+      max_tokens: Math.min(6000, maxTokens * attempt),
+      temperature: Number(argValue('temperature', '0.2')),
+      stream: false,
+      metadata: { source: 'qiyas-tadabbur-model-matrix', index, attempt },
+    };
+    requestAttempts.push({
+      attempt,
+      provider: modelSpec.provider,
+      model: modelSpec.model,
+      url: providerUrl(modelSpec.provider),
+      requestBody: redactRequest(body),
+      requestSha256: sha256(JSON.stringify(body)),
+    });
+    const response = await fetch(providerUrl(modelSpec.provider), {
+      method: 'POST',
+      headers: {
+        'content-type': 'application/json',
+        authorization: `Bearer ${providerApiKey(modelSpec.provider)}`,
+      },
+      body: JSON.stringify(body),
+    });
+    const rawText = await response.text();
+    let data = {};
+    try {
+      data = rawText ? JSON.parse(rawText) : {};
+    } catch {
+      data = { raw: rawText };
+    }
+    if (!response.ok) {
+      return {
+        ok: false,
+        skipped: false,
+        reason: `${modelSpec.provider} ${modelSpec.model} ${response.status}: ${rawText.slice(0, 500)}`,
+        text: '',
+        durationMs: Date.now() - started,
+        usage: data.usage || null,
+        usageDetails: completionUsageDetails(data),
+        rawSha256: sha256(rawText),
+        rawText,
+        attempts: attempt,
+        requestAttempts,
+      };
+    }
+    const text = data?.choices?.[0]?.message?.content || '';
+    if (String(text).trim()) {
+      return {
+        ok: true,
+        skipped: false,
+        reason: null,
+        text,
+        durationMs: Date.now() - started,
+        usage: data.usage || null,
+        usageDetails: completionUsageDetails(data),
+        rawSha256: sha256(rawText),
+        rawText,
+        attempts: attempt,
+        requestAttempts,
+      };
+    }
+    blanks.push({ attempt, usage: data.usage || null, usageDetails: completionUsageDetails(data), rawSha256: sha256(rawText), rawText });
+  }
+  return {
+    ok: false,
+    skipped: false,
+    visibleOutputFailure: true,
+    reason: `${modelSpec.provider} ${modelSpec.model} returned no visible answer text after ${attempts} attempt(s); usage=${JSON.stringify(blanks.map((blank) => blank.usageDetails))}`,
+    text: '',
+    durationMs: Date.now() - started,
+    usage: blanks.at(-1)?.usage || null,
+    usageDetails: blanks.at(-1)?.usageDetails || null,
+    rawSha256: blanks.at(-1)?.rawSha256 || null,
+    rawText: blanks.at(-1)?.rawText || '',
+    attempts,
+    requestAttempts,
+    blankAttempts: blanks.map((blank) => ({ attempt: blank.attempt, usageDetails: blank.usageDetails, rawSha256: blank.rawSha256 })),
+  };
+}
+
+function includeClaudeTerminalArm() {
+  return ['1', 'true', 'yes'].includes(String(argValue('claude-terminal', process.env.ARIA_QT_CLAUDE_TERMINAL || 'false')).toLowerCase());
+}
+
+function shellQuote(value) {
+  return `'${String(value).replaceAll("'", "'\\''")}'`;
+}
+
+function claudeTerminalCommand(prompt) {
+  const claudePath = process.env.ARIA_QT_CLAUDE_PATH || '/home/hamzaibrahim1/.local/bin/claude';
+  const model = argValue('claude-model', process.env.ARIA_QT_CLAUDE_MODEL || 'opus');
+  const budget = argValue('claude-budget-usd', process.env.ARIA_QT_CLAUDE_BUDGET_USD || '0.35');
+  return [
+    shellQuote(claudePath),
+    '--print',
+    '--input-format text',
+    '--output-format text',
+    '--no-session-persistence',
+    '--permission-mode plan',
+    '--tools ""',
+    `--model ${shellQuote(model)}`,
+    `--max-budget-usd ${shellQuote(budget)}`,
+    shellQuote(prompt),
+  ].join(' ');
+}
+
+function stripTerminalControls(text = '') {
+  return String(text || '')
+    .replace(/\u001b\[[0-?]*[ -/]*[@-~]/g, '')
+    .replace(/\u001b\][^\u0007]*(?:\u0007|\u001b\\)/g, '')
+    .replace(/\r/g, '')
+    .trim();
+}
+
+function callClaudeCodeTerminal(promptPair, index) {
+  const claudePath = process.env.ARIA_QT_CLAUDE_PATH || '/home/hamzaibrahim1/.local/bin/claude';
+  if (!existsSync(claudePath)) {
+    return {
+      ok: false,
+      skipped: true,
+      reason: `claude executable missing at ${claudePath}`,
+      text: '',
+      durationMs: 0,
+      usage: null,
+    };
+  }
+  const started = Date.now();
+  const prompt = [
+    directSystemPrompt(),
+    '',
+    matrixUserPrompt(promptPair.prompt),
+  ].join('\n');
+  const command = claudeTerminalCommand(prompt);
+  const timeoutMs = Number(argValue('claude-timeout-ms', process.env.ARIA_QT_CLAUDE_TIMEOUT_MS || '0'));
+  const result = spawnSync('script', ['-qefc', command, '/dev/null'], {
+    cwd: repoRoot,
+    encoding: 'utf8',
+    maxBuffer: 1024 * 1024 * 8,
+    ...(timeoutMs > 0 ? { timeout: timeoutMs } : {}),
+    env: {
+      ...process.env,
+      CLAUDE_CODE_SIMPLE: process.env.CLAUDE_CODE_SIMPLE || '1',
+    },
+  });
+  const stdout = result.stdout || '';
+  const stderr = result.stderr || '';
+  const text = stripTerminalControls(stdout);
+  const signal = result.signal || null;
+  const error = result.error ? String(result.error.message || result.error) : null;
+  const authFailure = /invalid api key|api key|auth|authentication|not logged in|login required/i.test(`${text}\n${stderr}`);
+  const ok = result.status === 0 && text.length > 0 && !signal && !error;
+  return {
+    ok,
+    skipped: authFailure,
+    terminalLaunched: true,
+    authFailure,
+    reason: ok ? null : authFailure
+      ? `claude terminal auth failure: ${text.slice(0, 200) || stderr.slice(0, 200)}`
+      : `claude terminal status=${result.status} signal=${signal || 'none'} error=${error || 'none'} stderr=${stderr.slice(0, 500)}`,
+    text: authFailure ? '' : text,
+    durationMs: Date.now() - started,
+    usage: null,
+    usageDetails: null,
+    inputPrompt: prompt,
+    inputPromptSha256: sha256(prompt),
+    requestBody: {
+      terminal: 'claude-code',
+      command: 'script -qefc <claude-code-terminal-command> /dev/null',
+      claudePath,
+      model: argValue('claude-model', process.env.ARIA_QT_CLAUDE_MODEL || 'opus'),
+      budgetUsd: argValue('claude-budget-usd', process.env.ARIA_QT_CLAUDE_BUDGET_USD || '0.35'),
+      permissionMode: 'plan',
+      tools: '',
+      promptSha256: sha256(prompt),
+      index,
+    },
+    rawSha256: sha256([stdout, stderr, result.status, signal, error].join('\n---\n')),
+    rawText: JSON.stringify({
+      command: 'script -qefc <claude-code-terminal-command> /dev/null',
+      terminalCommand: `<claude> --print --input-format text --output-format text --no-session-persistence --permission-mode plan --tools "" --model ${argValue('claude-model', process.env.ARIA_QT_CLAUDE_MODEL || 'opus')} --max-budget-usd ${argValue('claude-budget-usd', process.env.ARIA_QT_CLAUDE_BUDGET_USD || '0.35')} <prompt sha256=${sha256(prompt)}>`,
+      status: result.status,
+      signal,
+      error,
+      stdout,
+      stderr,
+      index,
+    }, null, 2),
+  };
+}
+
+function hasTerm(text, term) {
+  const escaped = term.replace(/[.*+?^${}()|[\]\\]/g, '\\$&').replace(/\\ /g, '\\s+');
+  return new RegExp(`\\b${escaped}\\b`, 'i').test(String(text || ''));
+}
+
+function countHits(text, terms) {
+  return terms.filter((term) => hasTerm(text, term)).length;
+}
+
+function scoreAnswer(text, prompt = '') {
+  const source = String(text || '');
+  const lower = source.toLowerCase();
+  const qiyasHits = countHits(source, qiyasPerspectives);
+  const tadabburHits = countHits(source, tadabburStages);
+  const hasFourPillars = ['asl', "far'", 'hukm', 'illah'].every((term) => lower.includes(term.replace("'", '')));
+  const furuq = /\bfuruq\b|false analog|material distinction/i.test(source);
+  const nextAction = /\b(next action|next step|do this|implement|run|verify|inspect|measure)\b/i.test(source);
+  const measurablePredicate = /\b(predicate|threshold|metric|score|pass|fail|delta|%|\d+\/\d+|artifact|sha256|exit=0)\b/i.test(source);
+  const evidenceBoundary = /\b(evidence|observed|verified|unverified|bounded|not measured|not proven|cannot verify)\b/i.test(source);
+  const learningLoop = /\b(lesson|learning|reflexion|dalio|feedback|record|future selection|update the loop)\b/i.test(source);
+  const ownerReadableFirst = !/^\s*<\s*(?:cognition|applied_cognition|qiyas_15_pass|tadabbur_questions)/i.test(source)
+    && source.length >= 250
+    && source.length <= 6000;
+  const noAskOnly = !/\bwhat would you like me to do next\b|\bhow would you like me to proceed\b/i.test(source);
+  const noFalseClosure = !/\b(guaranteed|fully complete|production ready|100% proven)\b/i.test(source);
+  const promptTerms = new Set(String(prompt).toLowerCase().split(/[^a-z0-9]+/).filter((term) => term.length > 5));
+  const promptTermHits = [...promptTerms].filter((term) => lower.includes(term)).length;
+  const score = (
+    qiyasHits * 0.8
+    + tadabburHits * 0.9
+    + (hasFourPillars ? 3 : 0)
+    + (furuq ? 2 : 0)
+    + (nextAction ? 2 : 0)
+    + (measurablePredicate ? 2 : 0)
+    + (evidenceBoundary ? 2 : 0)
+    + (learningLoop ? 1.5 : 0)
+    + (ownerReadableFirst ? 1.5 : 0)
+    + (noAskOnly ? 1 : -2)
+    + (noFalseClosure ? 1 : -3)
+    + Math.min(promptTermHits, 8) * 0.2
+  );
+  const findings = [];
+  if (qiyasHits < 15) findings.push(`qiyas coverage ${qiyasHits}/15`);
+  if (tadabburHits < 12) findings.push(`tadabbur coverage ${tadabburHits}/12`);
+  if (!hasFourPillars) findings.push('missing explicit four-pillar qiyas');
+  if (!furuq) findings.push('missing furuq false-analogy check');
+  if (!nextAction) findings.push('missing concrete next action');
+  if (!measurablePredicate) findings.push('missing measurable predicate');
+  if (!evidenceBoundary) findings.push('missing evidence boundary');
+  if (!learningLoop) findings.push('missing learning/reflexion loop');
+  if (!ownerReadableFirst) findings.push('owner-readable executive surface weak or bloated');
+  if (!noAskOnly) findings.push('ask-only ending');
+  if (!noFalseClosure) findings.push('false closure language');
+  return {
+    score: Number(score.toFixed(3)),
+    qiyasHits,
+    tadabburHits,
+    hasFourPillars,
+    furuq,
+    nextAction,
+    measurablePredicate,
+    evidenceBoundary,
+    learningLoop,
+    ownerReadableFirst,
+    noAskOnly,
+    noFalseClosure,
+    chars: source.length,
+    sha256: sha256(source),
+    findings,
+  };
+}
+
+function comparePromptRows(rows) {
+  const byPrompt = new Map();
+  for (const row of rows) {
+    if (!byPrompt.has(row.promptSha256)) byPrompt.set(row.promptSha256, []);
+    byPrompt.get(row.promptSha256).push(row);
+  }
+  const comparisons = [];
+  for (const group of byPrompt.values()) {
+    const scored = group.filter((row) => row.ok && row.score);
+    scored.sort((a, b) => b.score.score - a.score.score || b.score.qiyasHits - a.score.qiyasHits || b.score.tadabburHits - a.score.tadabburHits);
+    if (!scored.length) continue;
+    comparisons.push({
+      promptSha256: scored[0].promptSha256,
+      prompt: scored[0].prompt,
+      winner: scored[0].arm,
+      winnerScore: scored[0].score.score,
+      spread: Number((scored[0].score.score - scored[scored.length - 1].score.score).toFixed(3)),
+      rows: scored.map((row) => ({
+        arm: row.arm,
+        score: row.score.score,
+        qiyasHits: row.score.qiyasHits,
+        tadabburHits: row.score.tadabburHits,
+        findings: row.score.findings,
+      })),
+    });
+  }
+  return comparisons;
+}
+
+function renderMarkdown(summary, comparisons) {
+  const lines = [
+    '# Qiyas/Tadabbur Model Matrix',
+    '',
+    `- run_id: ${summary.runId}`,
+    `- prompts: ${summary.promptCount}`,
+    `- live model arms: ${summary.liveArms.join(', ') || 'none'}`,
+    `- terminal arms: ${summary.terminalArms.join(', ') || 'none'}`,
+    `- observed transcript arms: ${summary.observedArms.join(', ') || 'none'}`,
+    `- skipped arms: ${summary.skippedArms.join(', ') || 'none'}`,
+    `- visible output failures: ${summary.visibleOutputFailures}`,
+    `- terminal launch rows: ${summary.terminalLaunchRows}`,
+    `- evidence boundary: ${summary.evidenceBoundary}`,
+    '',
+    '## Aggregate',
+    '',
+    '| Arm | Calls | Mean | Qiyas Mean | Tadabbur Mean | Full Qiyas | Full Tadabbur | Fail Findings |',
+    '|---|---:|---:|---:|---:|---:|---:|---:|',
+    ...summary.armStats.map((row) => `| ${row.arm} | ${row.calls} | ${row.meanScore} | ${row.meanQiyas} | ${row.meanTadabbur} | ${row.fullQiyas} | ${row.fullTadabbur} | ${row.findingCount} |`),
+    '',
+    '## Per Prompt Winners',
+    '',
+    '| Prompt | Winner | Score | Spread |',
+    '|---|---|---:|---:|',
+    ...comparisons.map((row) => `| ${row.prompt.replaceAll('|', '\\|').slice(0, 220)} | ${row.winner} | ${row.winnerScore} | ${row.spread} |`),
+    '',
+    '## Gap Pattern',
+    '',
+    ...summary.topFindings.map((row) => `- ${row.finding}: ${row.count}`),
+    '',
+  ];
+  return lines.join('\n');
+}
+
+function mean(values) {
+  return values.length ? values.reduce((sum, value) => sum + value, 0) / values.length : 0;
+}
+
+function summarize(rows, prompts, models, comparisons) {
+  const scoredRows = rows.filter((row) => row.ok && row.score);
+  const armNames = [...new Set(rows.map((row) => row.arm))].sort();
+  const armStats = armNames.map((arm) => {
+    const armRows = scoredRows.filter((row) => row.arm === arm);
+    return {
+      arm,
+      calls: armRows.length,
+      meanScore: Number(mean(armRows.map((row) => row.score.score)).toFixed(3)),
+      meanQiyas: Number(mean(armRows.map((row) => row.score.qiyasHits)).toFixed(3)),
+      meanTadabbur: Number(mean(armRows.map((row) => row.score.tadabburHits)).toFixed(3)),
+      fullQiyas: armRows.filter((row) => row.score.qiyasHits === 15).length,
+      fullTadabbur: armRows.filter((row) => row.score.tadabburHits === 12).length,
+      findingCount: armRows.reduce((sum, row) => sum + row.score.findings.length, 0),
+    };
+  }).sort((a, b) => b.meanScore - a.meanScore);
+  const findingCounts = new Map();
+  for (const row of scoredRows) {
+    for (const finding of row.score.findings) {
+      findingCounts.set(finding, (findingCounts.get(finding) || 0) + 1);
+    }
+  }
+  const topFindings = [...findingCounts.entries()]
+    .map(([finding, count]) => ({ finding, count }))
+    .sort((a, b) => b.count - a.count)
+    .slice(0, 12);
+  return {
+    schema: 'aria.qiyas_tadabbur_model_matrix.v1',
+    runId,
+    generatedAt: new Date().toISOString(),
+    evidenceBoundary: 'Live arms are direct provider API calls. GPT/Codex and Claude entries are observed transcript outputs unless an API key/model is available. Scores are deterministic coverage/quality signals, not a statistically powered benchmark.',
+    promptCount: prompts.length,
+    models,
+    liveArms: models.filter((model) => model.apiKeyPresent).map((model) => model.id),
+    terminalArms: [...new Set(rows.filter((row) => row.source === 'claude_code_terminal').map((row) => row.arm))].sort(),
+    observedArms: [...new Set(rows.filter((row) => row.source === 'observed').map((row) => row.arm))].sort(),
+    skippedArms: rows.filter((row) => row.skipped).map((row) => row.arm),
+    visibleOutputFailures: rows.filter((row) => row.visibleOutputFailure || (!row.skipped && !row.ok && /no visible answer text/i.test(row.reason || ''))).length,
+    terminalLaunchRows: rows.filter((row) => row.terminalLaunched).length,
+    armStats,
+    topFindings,
+    comparisons: comparisons.map((row) => ({
+      promptSha256: row.promptSha256,
+      winner: row.winner,
+      winnerScore: row.winnerScore,
+      spread: row.spread,
+    })),
+    outputRoot,
+  };
+}
+
+function buildEvidenceManifest({ summary, promptPairs, rows, comparisons, artifacts }) {
+  return {
+    schema: 'aria.qiyas_tadabbur_model_matrix.evidence_manifest.v1',
+    runId,
+    generatedAt: new Date().toISOString(),
+    command: {
+      cwd: repoRoot,
+      argv: process.argv,
+    },
+    envKeyPresence: {
+      DEEPSEEK_API_KEY: Boolean(process.env.DEEPSEEK_API_KEY),
+      ARIA_DEEPSEEK_API_KEY: Boolean(process.env.ARIA_DEEPSEEK_API_KEY),
+      XAI_API_KEY: Boolean(process.env.XAI_API_KEY),
+      GROK_API_KEY: Boolean(process.env.GROK_API_KEY),
+      ANTHROPIC_API_KEY: Boolean(process.env.ANTHROPIC_API_KEY),
+      OPENAI_API_KEY: Boolean(process.env.OPENAI_API_KEY),
+    },
+    prompts: promptPairs.map((prompt) => ({
+      source: prompt.source,
+      model: prompt.model,
+      sourceSessionFile: prompt.file,
+      promptSha256: prompt.promptSha256,
+      chars: prompt.prompt.length,
+      inputPath: prompt.inputPath || null,
+    })),
+    rowArtifacts: rows.map((row) => ({
+      source: row.source,
+      arm: row.arm,
+      provider: row.provider,
+      model: row.model,
+      promptSha256: row.promptSha256,
+      sourceSessionFile: row.sourceSessionFile,
+      ok: row.ok,
+      skipped: row.skipped,
+      terminalLaunched: row.terminalLaunched === true,
+      visibleOutputFailure: row.visibleOutputFailure === true,
+      reason: row.reason,
+      attempts: row.attempts || null,
+      durationMs: row.durationMs,
+      usageDetails: row.usageDetails || null,
+      inputPath: row.inputPath || null,
+      requestPath: row.requestPath || null,
+      requestSha256: row.requestSha256 || null,
+      textPath: row.textPath || null,
+      rawPath: row.rawPath || null,
+      rawSha256: row.rawSha256 || null,
+      score: row.score ? {
+        score: row.score.score,
+        qiyasHits: row.score.qiyasHits,
+        tadabburHits: row.score.tadabburHits,
+        findings: row.score.findings,
+      } : null,
+    })),
+    comparisons: comparisons.map((row) => ({
+      promptSha256: row.promptSha256,
+      winner: row.winner,
+      winnerScore: row.winnerScore,
+      spread: row.spread,
+      rows: row.rows,
+    })),
+    summary,
+    artifacts,
+  };
+}
+
+async function main() {
+  ensureDir(outputRoot);
+  ensureDir(outputsDir);
+  const count = argNumber('count', 4, { min: 1, max: 100 });
+  const sessionLimit = argNumber('session-limit', 80, { min: 1, max: 500 });
+  const maxPromptChars = argNumber('max-prompt-chars', 1600, { min: 200, max: 8000 });
+  const concurrency = argNumber('concurrency', 4, { min: 1, max: 12 });
+  const promptPairs = collectPromptPairs({ sessionLimit, pairLimit: count, maxPromptChars });
+  if (!promptPairs.length) throw new Error('no relevant qiyas/tadabbur/autofire prompts found in local sessions');
+  const models = parseModels();
+  const liveWork = [];
+  for (const promptPair of promptPairs) {
+    for (const model of models) {
+      liveWork.push({ promptPair, model });
+    }
+  }
+  const rows = [];
+  const jsonlPath = path.join(outputRoot, 'rows.jsonl');
+  const liveRows = await mapConcurrent(liveWork, concurrency, async (work, index) => {
+    const result = await callChatModel(work.model, work.promptPair.prompt, index + 1);
+    const arm = work.model.id;
+    const artifactStem = `${String(index + 1).padStart(3, '0')}-${arm.replace(/[^a-z0-9._-]/gi, '_')}`;
+    const inputPath = path.join(outputsDir, `${artifactStem}.input.txt`);
+    const requestPath = path.join(outputsDir, `${artifactStem}.request.json`);
+    const textPath = path.join(outputsDir, `${artifactStem}.txt`);
+    const rawPath = path.join(outputsDir, `${artifactStem}.raw.json`);
+    writeFileSync(inputPath, work.promptPair.prompt);
+    if (result.requestAttempts?.length) writeJsonArtifact(requestPath, result.requestAttempts);
+    if (result.text) writeFileSync(textPath, result.text);
+    if (result.rawText) writeFileSync(rawPath, redactText(result.rawText));
+    const row = {
+      source: 'live_api',
+      arm,
+      provider: work.model.provider,
+      model: work.model.model,
+      prompt: work.promptPair.prompt,
+      promptSha256: work.promptPair.promptSha256,
+      sourceSessionFile: work.promptPair.file,
+      ok: result.ok,
+      skipped: result.skipped,
+      visibleOutputFailure: result.visibleOutputFailure === true,
+      reason: result.reason,
+      durationMs: result.durationMs,
+      usage: result.usage,
+      usageDetails: result.usageDetails || null,
+      attempts: result.attempts || 1,
+      blankAttempts: result.blankAttempts || [],
+      inputPath,
+      requestPath: result.requestAttempts?.length ? requestPath : null,
+      requestSha256: result.requestAttempts?.at(-1)?.requestSha256 || null,
+      textPath: result.text ? textPath : null,
+      rawPath: result.rawText ? rawPath : null,
+      rawSha256: result.rawSha256 || null,
+      score: result.text ? scoreAnswer(result.text, work.promptPair.prompt) : null,
+    };
+    writeFileSync(jsonlPath, JSON.stringify(redactRequest(row)) + '\n', { flag: 'a', mode: 0o644 });
+    process.stdout.write(JSON.stringify({
+      arm,
+      prompt: work.promptPair.promptSha256.slice(0, 8),
+      ok: row.ok,
+      skipped: row.skipped,
+      score: row.score?.score ?? null,
+      qiyas: row.score?.qiyasHits ?? null,
+      tadabbur: row.score?.tadabburHits ?? null,
+    }) + '\n');
+    return row;
+  });
+  rows.push(...liveRows);
+  if (includeClaudeTerminalArm()) {
+    for (const [index, promptPair] of promptPairs.entries()) {
+      const result = callClaudeCodeTerminal(promptPair, index + 1);
+      const arm = `claude-terminal:${argValue('claude-model', process.env.ARIA_QT_CLAUDE_MODEL || 'opus')}`;
+      const safeArm = arm.replace(/[^a-z0-9._-]/gi, '_');
+      const artifactStem = `${String(liveRows.length + index + 1).padStart(3, '0')}-${safeArm}`;
+      const inputPath = path.join(outputsDir, `${artifactStem}.input.txt`);
+      const requestPath = path.join(outputsDir, `${artifactStem}.request.json`);
+      const textPath = path.join(outputsDir, `${artifactStem}.txt`);
+      const rawPath = path.join(outputsDir, `${artifactStem}.raw.json`);
+      writeFileSync(inputPath, result.inputPrompt || promptPair.prompt);
+      writeJsonArtifact(requestPath, result.requestBody || {});
+      if (result.text) writeFileSync(textPath, result.text);
+      if (result.rawText) writeFileSync(rawPath, redactText(result.rawText));
+      const row = {
+        source: 'claude_code_terminal',
+        arm,
+        provider: 'claude-code-terminal',
+        model: argValue('claude-model', process.env.ARIA_QT_CLAUDE_MODEL || 'opus'),
+        prompt: promptPair.prompt,
+        promptSha256: promptPair.promptSha256,
+        sourceSessionFile: promptPair.file,
+        ok: result.ok,
+        skipped: result.skipped,
+        terminalLaunched: result.terminalLaunched === true,
+        reason: result.reason,
+        durationMs: result.durationMs,
+        usage: result.usage,
+        usageDetails: result.usageDetails || null,
+        inputPath,
+        requestPath,
+        requestSha256: sha256(JSON.stringify(result.requestBody || {})),
+        textPath: result.text ? textPath : null,
+        rawPath: result.rawText ? rawPath : null,
+        rawSha256: result.rawSha256 || null,
+        score: result.text ? scoreAnswer(result.text, promptPair.prompt) : null,
+      };
+      rows.push(row);
+      writeFileSync(jsonlPath, JSON.stringify(redactRequest(row)) + '\n', { flag: 'a', mode: 0o644 });
+      process.stdout.write(JSON.stringify({
+        arm,
+        prompt: promptPair.promptSha256.slice(0, 8),
+        ok: row.ok,
+        skipped: row.skipped,
+        terminalLaunched: row.terminalLaunched,
+        score: row.score?.score ?? null,
+        qiyas: row.score?.qiyasHits ?? null,
+        tadabbur: row.score?.tadabburHits ?? null,
+      }) + '\n');
+    }
+  }
+  for (const [index, promptPair] of promptPairs.entries()) {
+    if (!promptPair.observedAnswer) continue;
+    const arm = `${promptPair.source}:${promptPair.model}`;
+    const artifactStem = `${String(index + 1).padStart(3, '0')}-${arm.replace(/[^a-z0-9._-]/gi, '_')}-observed`;
+    const inputPath = path.join(outputsDir, `${artifactStem}.input.txt`);
+    const textPath = path.join(outputsDir, `${artifactStem}.txt`);
+    writeFileSync(inputPath, promptPair.prompt);
+    writeFileSync(textPath, promptPair.observedAnswer);
+    const row = {
+      source: 'observed',
+      arm,
+      provider: promptPair.source,
+      model: promptPair.model,
+      prompt: promptPair.prompt,
+      promptSha256: promptPair.promptSha256,
+      sourceSessionFile: promptPair.file,
+      ok: true,
+      skipped: false,
+      reason: null,
+      durationMs: null,
+      usage: null,
+      inputPath,
+      textPath,
+      score: scoreAnswer(promptPair.observedAnswer, promptPair.prompt),
+    };
+    rows.push(row);
+    writeFileSync(jsonlPath, JSON.stringify(redactRequest(row)) + '\n', { flag: 'a', mode: 0o644 });
+  }
+  const comparisons = comparePromptRows(rows);
+  const summary = summarize(rows, promptPairs, models.map((model) => ({ ...model, apiKeyPresent: Boolean(model.apiKeyPresent) })), comparisons);
+  const metricsPath = path.join(outputRoot, 'metrics.json');
+  const promptsPath = path.join(outputRoot, 'prompts.json');
+  const summaryPath = path.join(outputRoot, 'summary.md');
+  const evidenceManifestPath = path.join(outputRoot, 'evidence-manifest.json');
+  for (const promptPair of promptPairs) {
+    const promptInputPath = path.join(outputsDir, `${promptPair.promptSha256.slice(0, 12)}-prompt.input.txt`);
+    writeFileSync(promptInputPath, promptPair.prompt);
+    promptPair.inputPath = promptInputPath;
+  }
+  writeJsonArtifact(metricsPath, { summary, rows, comparisons });
+  writeFileSync(promptsPath, JSON.stringify(promptPairs.map((prompt) => ({
+    source: prompt.source,
+    model: prompt.model,
+    file: prompt.file,
+    prompt: prompt.prompt,
+    promptSha256: prompt.promptSha256,
+    inputPath: prompt.inputPath,
+  })), null, 2) + '\n');
+  writeFileSync(summaryPath, renderMarkdown(summary, comparisons));
+  const artifacts = { outputRoot, metricsPath, promptsPath, summaryPath, jsonlPath, evidenceManifestPath };
+  writeJsonArtifact(evidenceManifestPath, buildEvidenceManifest({ summary, promptPairs, rows, comparisons, artifacts }));
+  process.stdout.write(JSON.stringify({ ok: true, summary, artifacts }, null, 2) + '\n');
+}
+
+main().catch((error) => {
+  console.error(error instanceof Error ? error.stack : String(error));
+  process.exit(1);
+});