@aria_asi/cli 0.2.40 → 0.2.41

package/runtime-src/hive-wal-publisher.mjs

@@ -0,0 +1,292 @@
+#!/usr/bin/env node
+import { existsSync, mkdirSync, readFileSync, appendFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { homedir } from 'node:os';
+import { spawnSync } from 'node:child_process';
+
+const STATE_DIR = process.env.ARIA_RUNTIME_STATE_DIR || join(homedir(), '.aria', 'runtime', 'state');
+const WAL_PATH = process.env.ARIA_HIVE_WAL_PATH || join(STATE_DIR, 'hive-ledger-wal.jsonl');
+const PUBLISH_LEDGER_PATH = process.env.ARIA_HIVE_PUBLISH_LEDGER_PATH || join(STATE_DIR, 'hive-ledger-publish.jsonl');
+const QUERY_TIMEOUT_MS = Math.max(250, Number(process.env.ARIA_HIVE_POSTGRES_QUERY_TIMEOUT_MS || 750));
+const LIMIT = Math.max(1, Math.min(500, Number(process.env.ARIA_HIVE_WAL_PUBLISH_LIMIT || process.argv[2] || 100)));
+const POSTGRES_URL =
+  process.env.ARIA_HIVE_POSTGRES_URL ||
+  process.env.DATABASE_URL ||
+  process.env.POSTGRES_URL ||
+  'postgresql://postgres:postgres@127.0.0.1:5432/aria';
+
+function readJsonl(path) {
+  if (!existsSync(path)) return [];
+  return readFileSync(path, 'utf8')
+    .split('\n')
+    .filter(Boolean)
+    .map((line) => {
+      try {
+        return JSON.parse(line);
+      } catch {
+        return null;
+      }
+    })
+    .filter(Boolean);
+}
+
+function appendPublish(row, status, detail = {}) {
+  mkdirSync(dirname(PUBLISH_LEDGER_PATH), { recursive: true });
+  appendFileSync(PUBLISH_LEDGER_PATH, `${JSON.stringify({
+    schema: 'aria.hive_ledger_publish.v1',
+    wal_id: row?.wal_id || null,
+    kind: row?.kind || null,
+    status,
+    at: new Date().toISOString(),
+    publisher: 'hive-wal-publisher-sidecar',
+    detail,
+  })}\n`, { mode: 0o600 });
+}
+
+function sqlLiteral(value) {
+  if (value === null || value === undefined) return 'NULL';
+  return `'${String(value).replaceAll("'", "''")}'`;
+}
+
+function sqlJson(value) {
+  return `${sqlLiteral(JSON.stringify(value ?? null))}::jsonb`;
+}
+
+function psql(sql) {
+  const result = spawnSync('psql', ['-X', '-v', 'ON_ERROR_STOP=1', POSTGRES_URL], {
+    input: sql,
+    encoding: 'utf8',
+    timeout: QUERY_TIMEOUT_MS,
+    maxBuffer: 1024 * 1024,
+  });
+  if (result.error || result.signal || result.status !== 0) {
+    const detail = String(result.stderr || result.stdout || result.error?.message || result.signal || `exit ${result.status}`).trim();
+    throw new Error(detail.slice(0, 1000) || 'psql failed');
+  }
+  return result.stdout;
+}
+
+function ensureSchema() {
+  psql(`
+CREATE TABLE IF NOT EXISTS hive_file_touches (
+  touch_id text PRIMARY KEY,
+  session_id text,
+  thread_id text,
+  message_id text,
+  event text,
+  source text,
+  files jsonb NOT NULL DEFAULT '[]'::jsonb,
+  body jsonb NOT NULL DEFAULT '{}'::jsonb,
+  client_identity jsonb,
+  created_at timestamptz NOT NULL DEFAULT now()
+);
+CREATE INDEX IF NOT EXISTS hive_file_touches_session_idx ON hive_file_touches(session_id);
+CREATE INDEX IF NOT EXISTS hive_file_touches_thread_idx ON hive_file_touches(thread_id);
+CREATE INDEX IF NOT EXISTS hive_file_touches_created_idx ON hive_file_touches(created_at DESC);
+CREATE INDEX IF NOT EXISTS hive_file_touches_files_gin_idx ON hive_file_touches USING gin(files);
+
+CREATE TABLE IF NOT EXISTS hive_session_messages (
+  message_id text PRIMARY KEY,
+  thread_id text,
+  from_session_id text,
+  to_session_id text,
+  topic text,
+  body jsonb NOT NULL DEFAULT '{}'::jsonb,
+  client_identity jsonb,
+  created_at timestamptz NOT NULL DEFAULT now(),
+  read_at timestamptz,
+  read_by_session_ids jsonb NOT NULL DEFAULT '[]'::jsonb,
+  last_read_at timestamptz,
+  source text
+);
+CREATE INDEX IF NOT EXISTS hive_session_messages_thread_idx ON hive_session_messages(thread_id);
+CREATE INDEX IF NOT EXISTS hive_session_messages_to_session_idx ON hive_session_messages(to_session_id);
+CREATE INDEX IF NOT EXISTS hive_session_messages_from_session_idx ON hive_session_messages(from_session_id);
+CREATE INDEX IF NOT EXISTS hive_session_messages_topic_idx ON hive_session_messages(topic);
+CREATE INDEX IF NOT EXISTS hive_session_messages_created_idx ON hive_session_messages(created_at DESC);
+
+CREATE TABLE IF NOT EXISTS hive_session_threads (
+  thread_id text PRIMARY KEY,
+  topic text,
+  status text,
+  intent_summary text,
+  source_artifact text,
+  participants jsonb NOT NULL DEFAULT '[]'::jsonb,
+  file_claims jsonb NOT NULL DEFAULT '[]'::jsonb,
+  latest_client_identity jsonb,
+  latest_message_id text,
+  created_at timestamptz NOT NULL DEFAULT now(),
+  updated_at timestamptz NOT NULL DEFAULT now(),
+  source text
+);
+CREATE INDEX IF NOT EXISTS hive_session_threads_topic_idx ON hive_session_threads(topic);
+CREATE INDEX IF NOT EXISTS hive_session_threads_status_idx ON hive_session_threads(status);
+CREATE INDEX IF NOT EXISTS hive_session_threads_updated_idx ON hive_session_threads(updated_at DESC);
+CREATE INDEX IF NOT EXISTS hive_session_threads_participants_gin_idx ON hive_session_threads USING gin(participants);
+`);
+}
+
+function uniqueStrings(values) {
+  return [...new Set(values.filter((value) => typeof value === 'string' && value.trim()).map((value) => value.trim()))];
+}
+
+function publishFileTouch(row) {
+  const payload = row.payload || {};
+  const touchId = `${row.wal_id}_touch`;
+  psql(`
+INSERT INTO hive_file_touches (touch_id, session_id, thread_id, message_id, event, source, files, body, client_identity, created_at)
+VALUES (
+  ${sqlLiteral(touchId)},
+  ${sqlLiteral(payload.sessionId)},
+  ${sqlLiteral(payload.threadId || null)},
+  ${sqlLiteral(payload.messageId || null)},
+  ${sqlLiteral(payload.event || 'touch')},
+  ${sqlLiteral(payload.source || 'hive-wal-publisher-sidecar')},
+  ${sqlJson(Array.isArray(payload.files) ? payload.files : [])},
+  ${sqlJson(payload.body || {})},
+  ${sqlJson(payload.identity || null)},
+  ${sqlLiteral(payload.createdAt || row.created_at || new Date().toISOString())}::timestamptz
+)
+ON CONFLICT (touch_id) DO UPDATE SET
+  session_id = EXCLUDED.session_id,
+  thread_id = EXCLUDED.thread_id,
+  message_id = EXCLUDED.message_id,
+  event = EXCLUDED.event,
+  source = EXCLUDED.source,
+  files = EXCLUDED.files,
+  body = EXCLUDED.body,
+  client_identity = EXCLUDED.client_identity,
+  created_at = EXCLUDED.created_at;
+`);
+  appendPublish(row, 'published', { touch_id: touchId });
+}
+
+function publishLifecycle(row) {
+  const payload = row.payload || {};
+  const messageId = payload.messageId || `${row.wal_id}_message`;
+  const threadId = payload.threadId || `thread-${row.wal_id}`;
+  const participants = uniqueStrings([payload.fromSessionId, payload.toSessionId]);
+  const fileClaims = Array.isArray(payload.fileClaims) ? payload.fileClaims : [];
+
+  psql(`
+INSERT INTO hive_session_messages (message_id, thread_id, from_session_id, to_session_id, topic, body, client_identity, created_at, read_at, read_by_session_ids, last_read_at, source)
+VALUES (
+  ${sqlLiteral(messageId)},
+  ${sqlLiteral(threadId)},
+  ${sqlLiteral(payload.fromSessionId || null)},
+  ${sqlLiteral(payload.toSessionId || null)},
+  ${sqlLiteral(payload.topic || 'session.lifecycle')},
+  ${sqlJson(payload.normalizedBody || {})},
+  ${sqlJson(payload.identity || null)},
+  ${sqlLiteral(payload.createdAt || row.created_at || new Date().toISOString())}::timestamptz,
+  NULL,
+  '[]'::jsonb,
+  NULL,
+  ${sqlLiteral(payload.source || 'aria-mounted-runtime')}
+)
+ON CONFLICT (message_id) DO UPDATE SET
+  thread_id = EXCLUDED.thread_id,
+  from_session_id = EXCLUDED.from_session_id,
+  to_session_id = EXCLUDED.to_session_id,
+  topic = EXCLUDED.topic,
+  body = EXCLUDED.body,
+  client_identity = EXCLUDED.client_identity,
+  created_at = EXCLUDED.created_at,
+  source = EXCLUDED.source;
+
+INSERT INTO hive_session_threads (thread_id, topic, status, intent_summary, source_artifact, participants, file_claims, latest_client_identity, latest_message_id, created_at, updated_at, source)
+VALUES (
+  ${sqlLiteral(threadId)},
+  ${sqlLiteral(payload.topic || 'session.lifecycle')},
+  ${sqlLiteral(payload.threadStatus || payload.lifecycleStatus || 'active')},
+  ${sqlLiteral(payload.intentSummary || null)},
+  ${sqlLiteral(payload.sourceArtifact || null)},
+  ${sqlJson(participants)},
+  ${sqlJson(fileClaims)},
+  ${sqlJson(payload.identity || null)},
+  ${sqlLiteral(messageId)},
+  ${sqlLiteral(payload.createdAt || row.created_at || new Date().toISOString())}::timestamptz,
+  now(),
+  ${sqlLiteral(payload.source || 'aria-mounted-runtime')}
+)
+ON CONFLICT (thread_id) DO UPDATE SET
+  topic = EXCLUDED.topic,
+  status = EXCLUDED.status,
+  intent_summary = EXCLUDED.intent_summary,
+  source_artifact = EXCLUDED.source_artifact,
+  participants = (
+    SELECT COALESCE(jsonb_agg(DISTINCT value), '[]'::jsonb)
+    FROM jsonb_array_elements_text(hive_session_threads.participants || EXCLUDED.participants) AS value
+  ),
+  file_claims = EXCLUDED.file_claims,
+  latest_client_identity = EXCLUDED.latest_client_identity,
+  latest_message_id = EXCLUDED.latest_message_id,
+  updated_at = now(),
+  source = EXCLUDED.source;
+`);
+
+  if (fileClaims.length) {
+    publishFileTouch({
+      ...row,
+      kind: 'file_touch',
+      payload: {
+        sessionId: payload.fromSessionId,
+        threadId,
+        messageId,
+        event: payload.event || 'session.lifecycle',
+        source: 'hive-session-lifecycle-sidecar',
+        files: fileClaims,
+        body: {
+          lifecycle_event: payload.event || null,
+          lifecycle_status: payload.lifecycleStatus || null,
+          intent_summary: payload.intentSummary || null,
+          source_artifact: payload.sourceArtifact || null,
+          message_id: messageId,
+        },
+        identity: payload.identity || null,
+        createdAt: payload.createdAt || row.created_at,
+      },
+    });
+  }
+
+  appendPublish(row, 'published', { message_id: messageId, thread_id: threadId, file_claim_count: fileClaims.length });
+}
+
+function main() {
+  const published = new Set(
+    readJsonl(PUBLISH_LEDGER_PATH)
+      .filter((row) => row.status === 'published')
+      .map((row) => row.wal_id)
+      .filter(Boolean),
+  );
+  const rows = readJsonl(WAL_PATH)
+    .filter((row) => row?.schema === 'aria.hive_ledger_wal.v1')
+    .filter((row) => row.wal_id && !published.has(row.wal_id))
+    .slice(0, LIMIT);
+
+  if (!rows.length) {
+    console.log(JSON.stringify({ ok: true, published: 0, skipped: 0, limit: LIMIT }));
+    return;
+  }
+
+  ensureSchema();
+  let publishedCount = 0;
+  let failedCount = 0;
+  for (const row of rows) {
+    try {
+      if (row.kind === 'file_touch') publishFileTouch(row);
+      else if (row.kind === 'session_lifecycle') publishLifecycle(row);
+      else appendPublish(row, 'skipped', { reason: 'unknown_wal_kind' });
+      publishedCount += row.kind === 'file_touch' || row.kind === 'session_lifecycle' ? 1 : 0;
+    } catch (error) {
+      failedCount += 1;
+      appendPublish(row, 'failed', {
+        error: error instanceof Error ? error.message : String(error),
+        queryTimeoutMs: QUERY_TIMEOUT_MS,
+      });
+    }
+  }
+  console.log(JSON.stringify({ ok: failedCount === 0, published: publishedCount, failed: failedCount, scanned: rows.length, limit: LIMIT }));
+}
+
+main();

package/runtime-src/lib/evaluate-with-kernel.mjs

@@ -0,0 +1,133 @@
+// evaluate-with-kernel — the canonical decision helper for gate hooks across surfaces.
+//
+// Wraps compileCognitiveOptions from the deterministic cognitive kernel. Every new
+// gate (G1 behavioral guard, G6 goal contract eval, future doctrine-trigger-map
+// migration, etc.) should call this instead of writing regex.
+//
+// Doctrine: G0 of the Claude→Codex parity plan §12. Output is paraphrase-robust
+// because the kernel classifies by semantic action_class, not phrase match.
+//
+// The function is pure: same input → same output → same compilation_hash.
+// No I/O, no side effects, no logging. Caller logs as needed.
+
+import { compileCognitiveOptions, OUTPUT_EMIT_FAILURE_CLASSES } from './kernel/deterministic-cognitive-kernel.mjs';
+
+/**
+ * @param {object} input
+ * @param {string} input.surface      Caller surface label (e.g. 'claude-stop-gate', 'codex-pre-tool').
+ * @param {string} input.phase        Lifecycle phase (e.g. 'pre_cognition', 'post_tool', 'stop').
+ * @param {object} input.observation  Required. Must include kind + source; optional severity, attrs, title, summary.
+ * @param {Array}  [input.evidence]   Optional evidence anchors. Each: { anchor_type, source, observed, expected? }.
+ * @param {string} [input.predicate]  Verification predicate. Defaults to kernel's generic readback.
+ * @param {object} [input.policy]     Optional policy overrides passed to the kernel.
+ *
+ * @returns {object} {
+ *   ok: boolean,
+ *   decision: 'allow' | 'force_reauthor' | 'block' | 'observe_only',
+ *   topOption: { option_id, autonomy_level, title, rejected, rejection_reasons, verification_predicate, ... },
+ *   recoveryDirective: string,           // human-readable next-action prose
+ *   receiptHash: string,                 // sha256 of the compilation core; deterministic across runs
+ *   acceptance: { tadabbur_12, qiyas_15, cognition_mutated_output, deterministic_hash },
+ *   classification: { domain, action_class, blast_radius, reversibility, evidence_strength, ... },
+ *   tadabbur: { ok, stage_count, rows },
+ *   qiyas: { ok, perspective_count, rows },
+ *   sourceTrust: 'direct_observed' | 'substrate_recorded' | 'evidence_attached' | 'unverified',
+ *   meta: { surface, phase },
+ *   error?: { kind, message }
+ * }
+ */
+export function evaluateWithKernel({
+  surface = 'unknown',
+  phase = 'unknown',
+  observation,
+  evidence = [],
+  predicate = null,
+  policy = {},
+} = {}) {
+  if (!observation || typeof observation !== 'object') {
+    return {
+      ok: false,
+      decision: 'block',
+      error: { kind: 'invalid_input', message: 'observation is required and must be an object' },
+      meta: { surface, phase },
+    };
+  }
+
+  const compilation = compileCognitiveOptions(
+    { ...observation, evidence },
+    { verificationPredicate: predicate, policy },
+  );
+
+  const topOption = Array.isArray(compilation.options) && compilation.options.length > 0
+    ? compilation.options[0]
+    : null;
+
+  const decision = computeDecision(compilation, topOption);
+  const recoveryDirective = buildRecoveryDirective(compilation, topOption, decision);
+
+  return {
+    ok: true,
+    decision,
+    topOption,
+    recoveryDirective,
+    receiptHash: compilation.compilation_hash,
+    acceptance: compilation.acceptance,
+    classification: compilation.classification,
+    tadabbur: { ok: compilation.tadabbur.ok, stage_count: compilation.tadabbur.stage_count, rows: compilation.tadabbur.rows },
+    qiyas: { ok: compilation.qiyas.ok, perspective_count: compilation.qiyas.perspective_count, rows: compilation.qiyas.rows },
+    sourceTrust: compilation.source_trust,
+    meta: { surface, phase },
+  };
+}
+
+function computeDecision(compilation, topOption) {
+  // Output-emit failure classes get force_reauthor regardless of topOption.
+  // The kernel rejects repair options and leaves observe_only as the survivor,
+  // but observe_only-as-forced-fallback is semantically different from
+  // observe_only-as-natural-choice: the caller must re-author, not just observe.
+  const actionClass = compilation?.classification?.action_class;
+  if (actionClass && OUTPUT_EMIT_FAILURE_CLASSES.includes(actionClass)) {
+    return 'force_reauthor';
+  }
+  // The kernel signals "no real cognitive work happened" via cognition_mutated_output=false.
+  // That maps to force_reauthor — the caller emitted output without engaging the constraint layer.
+  if (compilation.acceptance && compilation.acceptance.cognition_mutated_output === false) {
+    return 'force_reauthor';
+  }
+  if (!topOption) return 'block';
+  if (topOption.rejected) return 'block';
+  if (topOption.option_id === 'observe_only') return 'observe_only';
+  return 'allow';
+}
+
+function buildRecoveryDirective(compilation, topOption, decision) {
+  const actionClass = compilation?.classification?.action_class || 'unknown';
+  if (decision === 'allow') {
+    return `Allowed. Top option=${topOption.option_id} autonomy=${topOption.autonomy_level}. Predicate: ${topOption.verification_predicate}`;
+  }
+  // force_reauthor for output-emit failure classes: surface the kernel's
+  // class-specific rejection reason (the workshop material the kernel
+  // emitted, not generic prose). The reason carries the doctrine-violation
+  // pattern + the exact shape of acceptable re-author.
+  if (decision === 'force_reauthor' && OUTPUT_EMIT_FAILURE_CLASSES.includes(actionClass)) {
+    const rejectedOptions = (compilation?.options || []).filter((o) => o.rejected);
+    const primaryReason = rejectedOptions[0]?.rejection_reasons?.[0]
+      || `Output classified as ${actionClass}; re-author required.`;
+    return `Re-author required (${actionClass}): ${primaryReason}`;
+  }
+  if (decision === 'observe_only') {
+    return `Observe-only mode. Preserve evidence; surface to operator before any state-changing action. Predicate: ${topOption.verification_predicate}`;
+  }
+  if (decision === 'force_reauthor') {
+    return 'Re-author required: cognition did not change the artifact. Either engage substrate (anchor lenses to loaded memory + axioms) or refuse to claim a state-change.';
+  }
+  // block
+  if (topOption && Array.isArray(topOption.rejection_reasons) && topOption.rejection_reasons.length > 0) {
+    return `Blocked: ${topOption.rejection_reasons[0]}`;
+  }
+  return 'Blocked: no acceptable option remained after kernel evaluation.';
+}
+
+// Re-export the kernel primitives so callers can use them without a second import.
+export { compileCognitiveOptions } from './kernel/deterministic-cognitive-kernel.mjs';
+export { TADABBUR_STAGES, QIYAS_PERSPECTIVES, stableHash, OUTPUT_EMIT_FAILURE_CLASSES } from './kernel/deterministic-cognitive-kernel.mjs';