auroq-os 2.5.8 → 2.5.10

package/.auroq-core/core-config.yaml

@@ -1,7 +1,7 @@
 project:
   name: "Auroq OS"
   type: greenfield
-  version: 2.5.8
+  version: 2.5.10
   installedAt: '2026-03-16'
 
 ide:

package/.claude/hooks/ahi/auth-config.cjs

@@ -0,0 +1,3 @@
+'use strict';
+// Public Supabase project configuration, shared with lib/supabase.js. Never use a service-role key.
+module.exports = { url: 'https://tzvfkdqzdkftcqfourom.supabase.co', publicKey: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InR6dmZrZHF6ZGtmdGNxZm91cm9tIiwicm9sZSI6ImFub24iLCJpYXQiOjE3Njg5NTA2MTQsImV4cCI6MjA4NDUyNjYxNH0.Ajmg36iq6Aj3x9L5DjpYZKOYpnjImqxVtU9rw5vkEAM' };

package/.claude/hooks/ahi/runtime.cjs

@@ -0,0 +1,226 @@
+'use strict';
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const crypto = require('node:crypto');
+const { spawn } = require('node:child_process');
+const S = require('./security.cjs');
+const VERSION = 'ahi-hooks-v2';
+const MAX_INPUT = 1024 * 1024;
+const MAX_EVENT = 60 * 1024;
+const MAX_QUEUE = 100 * 1024 * 1024;
+const MAX_FILES = 10000;
+const TTL = 7 * 24 * 3600 * 1000;
+const ACTIVE_TURN_TTL = 60 * 60 * 1000;
+const IDLE_TTL = 60 * 1000;
+const TERMINAL = ['Stop', 'SubagentStop', 'StopFailure', 'SessionEnd'];
+const TYPES = { UserPromptSubmit: 'message.user', Stop: 'message.assistant', SubagentStop: 'message.assistant', PreToolUse: 'tool.started', PostToolUse: 'tool.completed', PostToolUseFailure: 'tool.failed', SessionStart: 'session.started', SessionEnd: 'session.ended', Interrupt: 'coverage.gap', StopFailure: 'coverage.gap' };
+function credential() {
+  const cred = S.read(path.join(os.homedir(), '.arcane', 'credentials.json'));
+  return cred && /^[a-zA-Z0-9_-]{1,200}$/.test(cred.user?.id || '') && typeof cred.access_token === 'string' ? cred : null;
+}
+function configured(cwd, host = 'claude-code') {
+  if (host === 'codex') {
+    try {
+      const toml = fs.readFileSync(path.join(cwd, '.codex', 'config.toml'), 'utf8');
+      const block = toml.match(/^\[mcp_servers\.arcane\]\s*\n([\s\S]*?)(?=^\[|$(?![\s\S]))/m)?.[1];
+      if (!block || /^\s*enabled\s*=\s*false/m.test(block)) return false;
+    } catch { return false; }
+  }
+  const mcp = S.read(path.join(cwd, '.mcp.json'))?.mcpServers?.arcane;
+  if (!mcp || mcp.disabled === true || mcp.enabled === false) return false;
+  if (host === 'claude-code') {
+    for (const file of ['settings.json', 'settings.local.json']) {
+      const settings = S.read(path.join(cwd, '.claude', file), {});
+      if (settings.disableAllHooks || settings.disabledMcpjsonServers?.includes('arcane')) return false;
+    }
+  }
+  return true;
+}
+function resolveProject(cwd) {
+  const original = fs.realpathSync(cwd); let current = original;
+  for (let depth = 0; depth < 32; depth++) {
+    if (fs.existsSync(path.join(current, '.mcp.json')) || fs.existsSync(path.join(current, '.claude/hooks/ahi-capture.cjs'))) return current;
+    if (fs.existsSync(path.join(current, '.git'))) return original;
+    const parent = path.dirname(current); if (parent === current) break; current = parent;
+  }
+  return original;
+}
+function context(cwd = process.cwd(), host = 'claude-code', initialize = false) {
+  const project = resolveProject(cwd); const cred = credential();
+  if (!cred) return null;
+  const accountKey = S.hash(cred.user.id); const projectKey = S.hash(project);
+  const root = path.join(os.homedir(), '.arcane', 'ahi-v2');
+  const accountDir = path.join(root, accountKey); const dir = path.join(accountDir, projectKey);
+  const ctx = { project, host, cred, authId: cred.user.id, accountKey, projectKey, accountDir, dir, outbox: path.join(dir, 'outbox'), orderDir: path.join(dir, 'order'), scope: `${accountKey}:${projectKey}` };
+  if (initialize) {
+    for (const folder of [root, accountDir, dir, ctx.outbox, ctx.orderDir]) { S.safePath(folder); fs.mkdirSync(folder, { recursive: true, mode: 0o700 }); }
+  }
+  return ctx;
+}
+function lock(ctx, name, waitMs = ctx.lockWaitMs ?? 1500) {
+  const dir = path.join(ctx.dir, name); const start = Date.now();
+  while (true) {
+    try { fs.mkdirSync(dir, { mode: 0o700 }); S.atomic(path.join(dir, 'owner.json'), { pid: process.pid, created: Date.now() }, false, false); return () => { try { fs.rmSync(dir, { recursive: true }); } catch {} }; }
+    catch (e) {
+      if (e.code !== 'EEXIST') throw e;
+      S.safePath(dir);
+      const owner = S.read(path.join(dir, 'owner.json'));
+      let alive = true;
+      if (owner?.pid) { try { process.kill(owner.pid, 0); } catch (err) { alive = err.code !== 'ESRCH'; } }
+      else { try { alive = Date.now() - fs.statSync(dir).mtimeMs < 10000; } catch { continue; } }
+      if (!alive) { try { fs.rmSync(dir, { recursive: true }); } catch {} continue; }
+      if (Date.now() - start >= waitMs) return null;
+      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 10);
+    }
+  }
+}
+function state(ctx) { return S.read(path.join(ctx.dir, 'status.json'), { captured: 0, acked: 0, discarded: 0, excluded: 0, coverage: 'partial' }); }
+function update(ctx, changes) { S.atomic(path.join(ctx.dir, 'status.json'), { ...state(ctx), ...changes }); }
+function record(ctx, kind, reason, count = 1) {
+  const release = lock(ctx, 'state.lock'); if (!release) return;
+  try {
+    const current = state(ctx);
+    const changes = { [kind]: (current[kind] || 0) + count, last_problem: reason, last_problem_at: new Date().toISOString(), coverage: 'partial' };
+    update(ctx, changes);
+    const file = path.join(ctx.dir, 'receipts.jsonl');
+    if (fs.existsSync(file) && fs.statSync(file).size > 1024 * 1024) fs.renameSync(file, path.join(ctx.dir, 'receipts.previous.jsonl'));
+    fs.appendFileSync(file, JSON.stringify({ at: new Date().toISOString(), kind, reason, count }) + '\n', { mode: 0o600 });
+  } finally { release(); }
+}
+function validLease(ctx, session) {
+  const lease = S.read(path.join(ctx.dir, `lease-${S.hash(`${ctx.host}:${session || ''}`)}.json`));
+  // Boot marker + monotonic uptime prevent restart/offline and clock rollback extending a lease.
+  return lease?.enabled === true && lease.host === ctx.host && lease.native_session_id === session && lease.auth_user_id === ctx.authId && lease.boot === boot() && os.uptime() >= lease.uptime && os.uptime() < lease.untilUptime && Date.now() < lease.until ? lease : null;
+}
+function boot() { return Math.round((Date.now() / 1000 - os.uptime()) / 10); }
+function orderName(row) {
+  return `${String(row.captured_at).padStart(13, '0')}-${String(row.capture_order || 0).padStart(10, '0')}-${row.event.event_id}`;
+}
+function queueFiles(ctx) {
+  try {
+    const indexed = fs.readdirSync(ctx.orderDir).filter(name => /^\d{13}-\d{10}-[0-9a-f-]{36}$/.test(name)).sort();
+    const rows = indexed.map(name => ({ order: name, file: path.join(ctx.outbox, `${name.slice(-36)}.json`) })).filter(x => fs.existsSync(x.file));
+    const known = new Set(rows.map(x => path.basename(x.file)));
+    // Recovery for an interrupted upgrade/legacy v2 writer: rare orphans only, not every ciphertext per batch.
+    for (const name of fs.readdirSync(ctx.outbox).filter(n => /^[0-9a-f-]{36}\.json$/.test(n) && !known.has(n))) {
+      const file = path.join(ctx.outbox, name); const envelope = S.read(file);
+      const time = Number(envelope?.queued_at) || fs.statSync(file).mtimeMs;
+      rows.push({ order: `${String(Math.floor(time)).padStart(13, '0')}-${String(envelope?.capture_order || 0).padStart(10, '0')}-${name}`, file });
+    }
+    return rows.sort((a, b) => a.order.localeCompare(b.order)).map(x => x.file);
+  } catch { return []; }
+}
+function removeOrder(ctx, eventId) {
+  try { for (const name of fs.readdirSync(ctx.orderDir).filter(x => x.endsWith(eventId))) fs.unlinkSync(path.join(ctx.orderDir, name)); } catch {}
+}
+function queueBytes(ctx) {
+  try { return fs.readdirSync(ctx.outbox).reduce((n, name) => { const st = fs.lstatSync(path.join(ctx.outbox, name)); return n + (st.isFile() ? st.size : 0); }, 0); } catch { return 0; }
+}
+function queueRow(ctx, row, publicKey) {
+  const file = path.join(ctx.outbox, `${row.event.event_id}.json`);
+  if (fs.existsSync(file)) return false;
+  if (S.read(path.join(ctx.dir, `terminal-${row.event.event_id}.json`))) return false;
+  const sealed = S.seal(row, publicKey, ctx.scope); sealed.session_key = S.hash(`${row.host}:${row.native_session_id}`); sealed.queued_at = row.captured_at; sealed.capture_order = row.capture_order || 0;
+  const order = path.join(ctx.orderDir, orderName(row));
+  try { S.atomic(order, '', true); } catch (e) { if (e.code !== 'EEXIST') throw e; }
+  S.atomic(file, sealed, true);
+  return true;
+}
+function launch(ctx) {
+  if (process.env.NODE_ENV === 'test' && process.env.AHI_TEST_NO_WORKER === '1') return;
+  try {
+    const owner = S.read(path.join(ctx.dir, 'worker.lock', 'owner.json'));
+    if (owner?.pid) { try { process.kill(owner.pid, 0); return; } catch {} }
+    const child = spawn(process.execPath, [path.join(__dirname, 'worker.cjs'), ctx.project, ctx.host], { cwd: ctx.project, detached: true, windowsHide: true, stdio: 'ignore' });
+    child.unref();
+  } catch { record(ctx, 'excluded', 'WORKER_UNAVAILABLE', 0); }
+}
+function sessionFile(ctx, session) { return path.join(ctx.dir, `session-${S.hash(`${ctx.host}:${session}`)}.json`); }
+function eventFrom(input, session, occurrence) {
+  const name = input.hook_event_name || input.hookEventName;
+  const native = input.tool_use_id || input.call_id || input.event_id || input.message_id || (input.turn_id ? `${input.turn_id}:${input.agent_id || ''}` : null);
+  const origin = `${name}:${native || `local-${occurrence}`}`;
+  let type = TYPES[name];
+  if (name === 'PostToolUse' && (input.tool_response?.isError || input.tool_response?.error)) type = 'tool.failed';
+  let raw;
+  if (type === 'message.user') raw = { text: input.prompt };
+  else if (type === 'message.assistant') raw = { text: input.last_assistant_message, agent: input.agent_type || null };
+  else if (type?.startsWith('tool.')) raw = { tool: input.tool_name, input: input.tool_input ?? null, output: input.tool_response ?? null, error: input.error ?? null };
+  else raw = { reason: name === 'Interrupt' ? 'HOST_INTERRUPTED' : name === 'StopFailure' ? 'HOST_FAILED' : name };
+  let reason = null;
+  if (!type) { type = 'coverage.gap'; reason = 'UNSUPPORTED_HOOK'; }
+  if ((type === 'message.user' || type === 'message.assistant') && typeof raw.text !== 'string') { type = 'coverage.gap'; reason = 'MISSING_MESSAGE_TEXT'; }
+  const clean = S.scrub(raw);
+  if (Buffer.byteLength(JSON.stringify(clean.value)) > MAX_EVENT) { type = 'coverage.gap'; reason = 'EVENT_TOO_LARGE'; }
+  const payload = reason ? { reason, excluded_count: 1 } : { ...clean.value, identity_quality: native ? 'native' : 'local-occurrence', coverage: 'partial', excluded_fields: clean.excluded };
+  return { origin, event: { type, occurred_at: new Date().toISOString(), evidence_kind: 'observed', payload, redacted: clean.redacted, truncated: Boolean(reason || clean.excluded) } };
+}
+function capture(input, cwd = process.cwd(), host = 'claude-code') {
+  if (!['claude-code', 'codex'].includes(host) || !configured(cwd, host)) return { capture: 'off', reason: 'MCP_DISABLED' };
+  const ctx = context(cwd, host, true);
+  if (!ctx) return { capture: 'off', reason: 'AUTH_REQUIRED' };
+  const nativeSession = input.session_id || input.sessionId;
+  const session = typeof nativeSession === 'string' ? (/^[a-f0-9]{8}-[a-f0-9]{4}-[1-8][a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}$/i.test(nativeSession) ? nativeSession.toLowerCase() : S.id(nativeSession)) : null;
+  const name = input.hook_event_name || input.hookEventName;
+  // Allow an ordinary concurrent capture to finish; two bounded local waits stay below the host's 3s timeout.
+  if (TERMINAL.includes(name)) ctx.lockWaitMs = 500;
+  if (typeof session !== 'string' || !/^[a-zA-Z0-9_-]{1,200}$/.test(session) || !TYPES[name]) { record(ctx, 'excluded', 'UNSUPPORTED_SCHEMA'); return { capture: 'unsupported' }; }
+  S.atomic(path.join(ctx.dir, 'activity.json'), { at: Date.now(), host }, false, false);
+  const release = lock(ctx, 'capture.lock');
+  if (!release) { record(ctx, 'excluded', 'CAPTURE_BUSY'); return { capture: 'error' }; }
+  try {
+    const sf = sessionFile(ctx, session); const sess = S.read(sf, { seen_mcp: false, occurrence: 0 });
+    if (sess.revoked) return { capture: 'off', reason: 'SESSION_REVOKED' };
+    const usesMcp = /^mcp__arcane__/.test(input.tool_name || '') && /^(PreToolUse|PostToolUse|PostToolUseFailure)$/.test(name);
+    if (usesMcp) sess.seen_mcp = true;
+    sess.native_session_id = session; sess.occurrence++; sess.last_hook = name; sess.host = host; sess.active = name !== 'SessionEnd'; sess.last_seen = Date.now();
+    // Only real host activity extends a turn. License heartbeats never touch this deadline.
+    if (name === 'UserPromptSubmit' || ['PreToolUse', 'PostToolUse', 'PostToolUseFailure'].includes(name)) {
+      sess.turn_active = true; sess.turn_deadline = sess.last_seen + ACTIVE_TURN_TTL; sess.turn_expired = false;
+    } else if (['Stop', 'StopFailure', 'SessionEnd', 'Interrupt'].includes(name)) {
+      sess.turn_active = false; sess.turn_deadline = null;
+    } else if (name === 'SubagentStop' && sess.turn_active) {
+      // The child finishing is activity, not the end of its parent's turn.
+      sess.turn_deadline = sess.last_seen + ACTIVE_TURN_TTL;
+    }
+    S.atomic(sf, sess);
+    if (!sess.seen_mcp) { launch(ctx); return { capture: 'waiting_mcp', reason: 'NO_MCP_USE_IN_SESSION' }; }
+    if (!validLease(ctx, session)) { launch(ctx); return { capture: 'waiting_lease' }; }
+    const publicKey = S.read(path.join(ctx.dir, 'public-key.json'))?.key;
+    if (!publicKey || S.hash(publicKey) !== validLease(ctx, session).key_fingerprint) { record(ctx, 'excluded', 'SECURE_STORAGE_UNAVAILABLE'); launch(ctx); return { capture: 'unsupported' }; }
+    const files = queueFiles(ctx); const bytes = queueBytes(ctx);
+    if (files.length >= MAX_FILES || bytes >= MAX_QUEUE) { record(ctx, 'excluded', 'QUEUE_QUOTA'); launch(ctx); return { capture: 'limited' }; }
+    const current = state(ctx);
+    if (current.excluded > (current.reported_excluded || 0)) {
+      const gapId = S.id(`${ctx.scope}:local-exclusions:${current.excluded}`);
+      const gap = { schema_version: 1, host, adapter_version: VERSION, project_key: ctx.projectKey, native_session_id: session, captured_at: Date.now(), event: { event_id: gapId, source_event_id: `CoverageGap:${S.hash(gapId)}`, type: 'coverage.gap', occurred_at: new Date().toISOString(), evidence_kind: 'observed', redacted: false, truncated: true, payload: { reason: 'LOCAL_EXCLUSIONS', scope: 'project', excluded_count: current.excluded - (current.reported_excluded || 0), latest_reason: current.last_problem || 'UNKNOWN', coverage: 'partial' } } };
+      queueRow(ctx, gap, publicKey);
+      update(ctx, { reported_excluded: current.excluded });
+    }
+    const item = eventFrom(input, session, sess.occurrence);
+    const eventId = S.id(`${ctx.scope}:${host}:${session}:${item.origin}:${S.hash(JSON.stringify(item.event.payload))}`);
+    item.event.event_id = eventId; item.event.source_event_id = `${name}:${S.hash(`${item.origin}:${S.hash(JSON.stringify(item.event.payload))}`)}`;
+    // Stable identity/revisions, plus first observed timestamp, survive transport retries.
+    const row = { schema_version: 1, host, adapter_version: VERSION, project_key: ctx.projectKey, native_session_id: session, captured_at: Date.now(), capture_order: sess.occurrence, event: item.event };
+    const added = queueRow(ctx, row, publicKey);
+    if (added) {
+      const releaseState = lock(ctx, 'state.lock');
+      if (releaseState) { try { const st = state(ctx); update(ctx, { captured: st.captured + 1, last_capture_at: new Date().toISOString(), capability: `${host}:hooks-partial`, last_host: host }); } finally { releaseState(); } }
+    }
+    launch(ctx); return { capture: 'queued', event_id: eventId, duplicate: !added };
+  } finally { release(); }
+}
+function status(cwd = process.cwd(), host = 'claude-code') {
+  cwd = resolveProject(cwd);
+  const on = configured(cwd, host); const ctx = context(cwd, host);
+  const st = ctx ? state(ctx) : {};
+  const installed = fs.existsSync(path.join(cwd, '.claude/hooks/ahi-capture.cjs'));
+  const files = ctx ? queueFiles(ctx) : [];
+  const sessions = ctx && fs.existsSync(ctx.dir) ? fs.readdirSync(ctx.dir).filter(x => /^session-[a-f0-9]+\.json$/.test(x)).map(x => S.read(path.join(ctx.dir, x))).filter(Boolean) : [];
+  const activeTurns = sessions.filter(x => x.host === host && x.active && x.turn_active && x.turn_deadline > Date.now()).length;
+  const lease = ctx ? sessions.some(x => x.host === host && x.seen_mcp && x.active && validLease(ctx, x.native_session_id)) : null;
+  const reason = !on ? 'MCP_DISABLED' : !installed ? 'HOOK_NOT_INSTALLED' : !ctx ? 'AUTH_REQUIRED' : !lease ? 'NO_VALID_LICENSE_LEASE' : !st.last_capture_at ? 'NO_CAPTURE_PROVEN' : null;
+  return { ok: true, configured: on, capture: reason ? 'inactive' : 'active_partial', reason, host, adapter_version: VERSION, coverage: 'partial', active_turns: activeTurns, active_turn_timeout_ms: ACTIVE_TURN_TTL, capability: 'visible_hook_messages_and_tools', unsupported: ['intermediate_assistant_messages', 'transcripts', 'binary_artifacts', 'global_history'], pending: files.length, pending_bytes: ctx ? queueBytes(ctx) : 0, last_ack_at: st.last_ack_at || null, captured: st.captured || 0, acked: st.acked || 0, discarded: st.discarded || 0, excluded: st.excluded || 0, last_problem: st.last_problem || null, pause: false, legacy_plaintext_exists: fs.existsSync(path.join(cwd, '.auroq/ahi/events.jsonl')), legacy_imported: false, secure_storage: S.read(ctx ? path.join(ctx.dir, 'public-key.json') : '', {})?.key ? 'public_envelope_os_keystore' : 'unavailable' };
+}
+module.exports = { VERSION, MAX_INPUT, MAX_EVENT, MAX_QUEUE, MAX_FILES, TTL, ACTIVE_TURN_TTL, IDLE_TTL, TERMINAL, TYPES, credential, configured, resolveProject, context, lock, state, update, record, validLease, boot, queueFiles, queueBytes, queueRow, removeOrder, launch, capture, status };

package/.claude/hooks/ahi/security.cjs

@@ -0,0 +1,162 @@
+'use strict';
+const fs = require('node:fs');
+const path = require('node:path');
+const crypto = require('node:crypto');
+const { spawnSync } = require('node:child_process');
+const SECRET_KEY = /(?:password|passwd|senha|secret|token|authorization|cookie|api.?key|private.?key|credentials?|^env$|^environment$)/i;
+const REDACTED = '[REDACTED]';
+function hash(value) { return crypto.createHash('sha256').update(String(value)).digest('hex'); }
+function id(value) { const h = hash(value); return `${h.slice(0, 8)}-${h.slice(8, 12)}-5${h.slice(13, 16)}-a${h.slice(17, 20)}-${h.slice(20, 32)}`; }
+function scrub(value) {
+  let redacted = false; let excluded = 0;
+  const replace = (s, re, out = REDACTED) => s.replace(re, () => { redacted = true; return out; });
+  function text(s) {
+    s = replace(s, /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?(?:-----END [A-Z ]*PRIVATE KEY-----|$)/g);
+    s = s.replace(/((?:minha\s+)?(?:senha|password|token|api[_-]?key)\s+(?:é|eh|is)\s+)(?:"[^"\n]*"|'[^'\n]*'|[^\s,;}]+)/gi, (_, prefix) => { redacted = true; return `${prefix}${REDACTED}`; });
+    s = replace(s, /\b(?:Bearer|Basic)\s+\S+/gi);
+    s = replace(s, /\b(?:sk-(?:proj-|ant-|live_|test_)?|gh[pousr]_|github_pat_|xox[baprs]-|AKIA|ASIA|AIza)[A-Za-z0-9_\-]{12,}/g);
+    s = replace(s, /\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b/g);
+    s = s.replace(/([a-z][a-z0-9+.-]*:\/\/)([^\s/@]+@)/gi, (_, scheme) => { redacted = true; return `${scheme}${REDACTED}@`; });
+    s = s.replace(/([?&](?:[^=\s]*(?:token|key|secret|password|signature|credential)[^=\s]*)=)[^&#\s]*/gi, (_, prefix) => { redacted = true; return `${prefix}${REDACTED}`; });
+    s = s.replace(/((?:password|passwd|senha|secret|token|api[_-]?key|authorization|cookie)[\"']?\s*[=:]\s*)(?:"[^"\n]*"|'[^'\n]*'|[^\s,;}]+)/gi, (_, prefix) => { redacted = true; return `${prefix}${REDACTED}`; });
+    // Unknown long opaque strings are not safe to archive. Fail closed for that value.
+    s = replace(s, /\b[A-Za-z0-9_+/=-]{32,}\b/g);
+    return s;
+  }
+  function walk(v, depth) {
+    if (depth > 10) { excluded++; return '[EXCLUDED:depth]'; }
+    if (typeof v === 'string') {
+      if (/^\s*[\[{"]/.test(v)) { try { return JSON.stringify(walk(JSON.parse(v), depth + 1)); } catch {} }
+      return text(v);
+    }
+    if (v === null || typeof v === 'boolean' || (typeof v === 'number' && Number.isFinite(v))) return v;
+    if (Array.isArray(v)) { if (v.length > 200) excluded += v.length - 200; return v.slice(0, 200).map(x => walk(x, depth + 1)); }
+    if (v && typeof v === 'object') {
+      const out = {}; const entries = Object.entries(v);
+      if (entries.length > 200) excluded += entries.length - 200;
+      for (const [k, x] of entries.slice(0, 200)) {
+        if (['__proto__', 'constructor', 'prototype'].includes(k)) { excluded++; continue; }
+        if (SECRET_KEY.test(k)) { out[k] = REDACTED; redacted = true; }
+        else out[text(k)] = walk(x, depth + 1);
+      }
+      return out;
+    }
+    excluded++; return '[EXCLUDED:type]';
+  }
+  const clean = walk(value, 0);
+  return { value: clean, redacted, excluded };
+}
+function safePath(file) {
+  let cursor = path.resolve(file);
+  while (cursor !== path.dirname(cursor)) {
+    try { if (fs.lstatSync(cursor).isSymbolicLink()) throw new Error('UNSAFE_SYMLINK'); } catch (e) { if (e.code !== 'ENOENT') throw e; }
+    cursor = path.dirname(cursor);
+  }
+}
+function powershell(script, input) {
+  // Windows PowerShell 5.1 must build its own module path when launched through Node/pwsh 7.
+  // Keep the caller's environment unchanged, including differently cased Windows names.
+  const env = Object.fromEntries(Object.entries(process.env).filter(([name]) => name.toLowerCase() !== 'psmodulepath'));
+  const result = spawnSync('powershell.exe', ['-NoLogo', '-NoProfile', '-NonInteractive', '-EncodedCommand', Buffer.from(`$ErrorActionPreference='Stop'; $PSModuleAutoLoadingPreference='None'; ${script}`, 'utf16le').toString('base64')], { input, env, encoding: 'utf8', timeout: 5000, windowsHide: true, maxBuffer: 65536 });
+  if (result.status !== 0 || result.error) throw new Error('SECURE_STORAGE_UNAVAILABLE');
+  return result.stdout.trim();
+}
+function protectMany(dirs) {
+  const unique = [...new Set(dirs)]; if (!unique.length) return;
+  for (const dir of unique) { safePath(dir); fs.mkdirSync(dir, { recursive: true, mode: 0o700 }); }
+  if (process.platform === 'win32') {
+    // Core .NET APIs avoid the variable cold cost of preparing PowerShell cmdlet modules.
+    // Keep the exact same private DACL: current owner + SYSTEM, no inherited external access.
+    const encoded = unique.map(dir => `'${Buffer.from(dir).toString('base64')}'`).join(',');
+    powershell(`$sid=[Security.Principal.WindowsIdentity]::GetCurrent().User; foreach($encoded in @(${encoded})){ $p=[Text.Encoding]::UTF8.GetString([Convert]::FromBase64String($encoded)); $acl=[Security.AccessControl.DirectorySecurity]::new(); $acl.SetOwner($sid); $acl.SetAccessRuleProtection($true,$false); foreach($s in @($sid,[Security.Principal.SecurityIdentifier]::new('S-1-5-18'))){ $rule=[Security.AccessControl.FileSystemAccessRule]::new($s,[Security.AccessControl.FileSystemRights]::FullControl,[Security.AccessControl.InheritanceFlags]'ContainerInherit,ObjectInherit',[Security.AccessControl.PropagationFlags]::None,[Security.AccessControl.AccessControlType]::Allow); [void]$acl.AddAccessRule($rule) }; [void][IO.Directory]::SetAccessControl($p,$acl) }`);
+  } else {
+    for (const dir of unique) {
+      fs.chmodSync(dir, 0o700);
+      const stat = fs.statSync(dir);
+      if ((stat.mode & 0o077) !== 0 || (process.getuid && stat.uid !== process.getuid())) throw new Error('UNSAFE_PERMISSIONS');
+    }
+  }
+}
+function protect(dir) { protectMany([dir]); }
+// Non-durable mode is only for transient process lock/activity hints, never queue/ACK/key material.
+function atomic(file, value, exclusive = false, durable = true) {
+  safePath(file);
+  const tmp = `${file}.${crypto.randomUUID()}.tmp`;
+  const fd = fs.openSync(tmp, 'wx', 0o600);
+  try { fs.writeFileSync(fd, typeof value === 'string' ? value : JSON.stringify(value)); if (durable) fs.fsyncSync(fd); } finally { fs.closeSync(fd); }
+  try {
+    if (exclusive) { fs.linkSync(tmp, file); fs.unlinkSync(tmp); }
+    else fs.renameSync(tmp, file);
+    if (durable && process.platform !== 'win32') { const dir = fs.openSync(path.dirname(file), 'r'); try { fs.fsyncSync(dir); } finally { fs.closeSync(dir); } }
+  } catch (e) { try { fs.unlinkSync(tmp); } catch {} throw e; }
+}
+function read(file, fallback = null) {
+  try { safePath(file); const st = fs.statSync(file); if (st.size > 1024 * 1024) return fallback; return JSON.parse(fs.readFileSync(file, 'utf8')); } catch { return fallback; }
+}
+function keyFor(ctx, create = false) {
+  if (process.env.NODE_ENV === 'test' && process.env.AHI_TEST_MODE === '1' && process.env.AHI_TEST_NATIVE_KEYSTORE !== '1') {
+    if (!/^[a-f0-9]{64}$/.test(process.env.AHI_TEST_KEY || '')) throw new Error('SECURE_STORAGE_UNAVAILABLE');
+    return Buffer.from(process.env.AHI_TEST_KEY, 'hex');
+  }
+  if (!/^[a-f0-9]{64}$/.test(ctx.accountKey)) throw new Error('UNSAFE_ACCOUNT_KEY');
+  if (process.platform === 'darwin') {
+    const service = 'education.arka.ahi.v2'; const account = ctx.accountKey;
+    const keychain = ctx.keychainPath && /^[A-Za-z0-9_./-]+$/.test(ctx.keychainPath) ? ctx.keychainPath : null;
+    const find = () => spawnSync('/usr/bin/security', ['find-generic-password', '-s', service, '-a', account, '-w', ...(keychain ? [keychain] : [])], { encoding: 'utf8', timeout: 1200, maxBuffer: 4096 });
+    let result = find();
+    if (result.status !== 0 && create) {
+      const key = crypto.randomBytes(32).toString('hex');
+      // Interactive command from stdin keeps key material out of process arguments.
+      const add = spawnSync('/usr/bin/security', ['-i'], { input: `add-generic-password -s ${service} -a ${account} -w ${key}${keychain ? ` ${keychain}` : ''}\n`, encoding: 'utf8', timeout: 1500, maxBuffer: 4096 });
+      if (add.error) throw new Error('SECURE_STORAGE_UNAVAILABLE');
+      result = find();
+    }
+    const raw = (result.stdout || '').trim();
+    if (result.status !== 0 || !/^[a-f0-9]{64}$/.test(raw)) throw new Error('SECURE_STORAGE_UNAVAILABLE');
+    return Buffer.from(raw, 'hex');
+  }
+  if (process.platform === 'win32') {
+    const file = path.join(ctx.accountDir, 'key.dpapi');
+    if (!fs.existsSync(file)) {
+      if (!create) throw new Error('SECURE_STORAGE_UNAVAILABLE');
+      const wrapped = powershell("[void][Reflection.Assembly]::Load('System.Security, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a'); $b=[byte[]]::new(32); $rng=[Security.Cryptography.RandomNumberGenerator]::Create(); try { $rng.GetBytes($b); [Console]::Write([Convert]::ToBase64String([Security.Cryptography.ProtectedData]::Protect($b,$null,[Security.Cryptography.DataProtectionScope]::CurrentUser))) } finally { $rng.Dispose(); [Array]::Clear($b,0,$b.Length) }");
+      if (!/^[A-Za-z0-9+/]+={0,2}$/.test(wrapped) || Buffer.from(wrapped, 'base64').length < 32) throw new Error('SECURE_STORAGE_UNAVAILABLE');
+      try { atomic(file, wrapped, true); } catch (e) { if (e.code !== 'EEXIST') throw e; }
+    }
+    safePath(file);
+    const wrapped = fs.readFileSync(file, 'utf8');
+    const raw = powershell("[void][Reflection.Assembly]::Load('System.Security, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a'); $b=[Convert]::FromBase64String([Console]::In.ReadToEnd().Trim()); $plain=[Security.Cryptography.ProtectedData]::Unprotect($b,$null,[Security.Cryptography.DataProtectionScope]::CurrentUser); try { [Console]::Write([Convert]::ToBase64String($plain)) } finally { [Array]::Clear($plain,0,$plain.Length) }", wrapped);
+    const key = Buffer.from(raw, 'base64'); if (key.length !== 32) throw new Error('SECURE_STORAGE_UNAVAILABLE'); return key;
+  }
+  throw new Error('UNSUPPORTED_OS_KEYSTORE');
+}
+function encrypt(value, key, scope) {
+  const iv = crypto.randomBytes(12); const cipher = crypto.createCipheriv('aes-256-gcm', key, iv); cipher.setAAD(Buffer.from(`ahi-envelope-v2:${scope}`));
+  const body = Buffer.concat([cipher.update(JSON.stringify(value)), cipher.final()]);
+  return { v: 2, iv: iv.toString('base64'), tag: cipher.getAuthTag().toString('base64'), body: body.toString('base64') };
+}
+function decrypt(value, key, scope) {
+  if (!value || value.v !== 2) throw new Error('QUEUE_CORRUPT');
+  const cipher = crypto.createDecipheriv('aes-256-gcm', key, Buffer.from(value.iv, 'base64')); cipher.setAAD(Buffer.from(`ahi-envelope-v2:${scope}`)); cipher.setAuthTag(Buffer.from(value.tag, 'base64'));
+  return JSON.parse(Buffer.concat([cipher.update(Buffer.from(value.body, 'base64')), cipher.final()]).toString('utf8'));
+}
+function privateKey(seed) {
+  return crypto.createPrivateKey({ key: Buffer.concat([Buffer.from('302e020100300506032b656e04220420', 'hex'), seed]), format: 'der', type: 'pkcs8' });
+}
+function publicKey(seed) { return crypto.createPublicKey(privateKey(seed)).export({ format: 'der', type: 'spki' }).toString('base64'); }
+function seal(value, recipient, scope) {
+  const pair = crypto.generateKeyPairSync('x25519');
+  const publicRecipient = crypto.createPublicKey({ key: Buffer.from(recipient, 'base64'), format: 'der', type: 'spki' });
+  const shared = crypto.diffieHellman({ privateKey: pair.privateKey, publicKey: publicRecipient });
+  const key = Buffer.from(crypto.hkdfSync('sha256', shared, Buffer.from(scope), Buffer.from('ahi-envelope-v2'), 32));
+  const result = encrypt(value, key, scope); key.fill(0); shared.fill(0);
+  result.ephemeral = pair.publicKey.export({ format: 'der', type: 'spki' }).toString('base64');
+  return result;
+}
+function open(value, seed, scope) {
+  const publicSender = crypto.createPublicKey({ key: Buffer.from(value.ephemeral, 'base64'), format: 'der', type: 'spki' });
+  const shared = crypto.diffieHellman({ privateKey: privateKey(seed), publicKey: publicSender });
+  const key = Buffer.from(crypto.hkdfSync('sha256', shared, Buffer.from(scope), Buffer.from('ahi-envelope-v2'), 32));
+  try { return decrypt(value, key, scope); } finally { key.fill(0); shared.fill(0); }
+}
+module.exports = { hash, id, scrub, protect, protectMany, safePath, atomic, read, keyFor, encrypt, decrypt, publicKey, seal, open };