auroq-os 2.5.7 → 2.5.9

package/.claude/hooks/ahi/worker.cjs

@@ -0,0 +1,252 @@
+'use strict';
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+const http = require('node:http');
+const https = require('node:https');
+const R = require('./runtime.cjs');
+const S = require('./security.cjs');
+function baseUrl() {
+  if (process.env.NODE_ENV === 'test' && process.env.AHI_TEST_MODE === '1' && process.env.AHI_TEST_URL) {
+    const url = new URL(process.env.AHI_TEST_URL);
+    if (!['127.0.0.1', 'localhost', '[::1]'].includes(url.hostname)) throw new Error('UNSAFE_TEST_ENDPOINT');
+    return url.origin;
+  }
+  return 'https://arcane.arka.education';
+}
+function request(url, token, body, extraHeaders = {}) {
+  return new Promise(resolve => {
+    let finished = false; let timer;
+    const finish = value => { if (finished) return; finished = true; clearTimeout(timer); resolve(value); };
+    const target = new URL(url); const data = body === undefined ? null : JSON.stringify(body);
+    const transport = target.protocol === 'https:' ? https : http;
+    const req = transport.request(target, { method: data ? 'POST' : 'GET', headers: { ...(token ? { Authorization: `Bearer ${token}` } : {}), ...(data ? { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(data) } : {}), ...extraHeaders }, timeout: 4000 }, res => {
+      let bytes = 0; let text = '';
+      res.on('data', chunk => { bytes += chunk.length; if (bytes > 128 * 1024) { req.destroy(); finish({ code: 0, error: 'RESPONSE_TOO_LARGE' }); } else text += chunk; });
+      res.on('end', () => { let json; try { json = JSON.parse(text); } catch {} const numericRetry = Number(res.headers['retry-after']); const retry = Number.isFinite(numericRetry) ? numericRetry * 1000 : Date.parse(res.headers['retry-after']) - Date.now(); finish({ code: res.statusCode, body: json, retryMs: Number.isFinite(retry) ? Math.min(300000, Math.max(0, retry)) : 0 }); });
+    });
+    req.on('error', () => finish({ code: 0, error: 'NETWORK_ERROR' }));
+    req.on('timeout', () => { req.destroy(); finish({ code: 0, error: 'NETWORK_TIMEOUT' }); });
+    timer = setTimeout(() => { req.destroy(); finish({ code: 0, error: 'NETWORK_TIMEOUT' }); }, 4000);
+    if (data) req.write(data); req.end();
+  });
+}
+async function getCredential(ctx) {
+  let cred = R.credential();
+  if (!cred || cred.user.id !== ctx.authId) return null;
+  if (Number(cred.expires_at) > Date.now() / 1000 + 60) return cred;
+  if (!cred.refresh_token) return cred;
+  if (!fs.existsSync(ctx.accountDir)) S.protect(ctx.accountDir);
+  const release = R.lock({ ...ctx, dir: ctx.accountDir }, 'auth.lock', 0);
+  if (!release) return cred;
+  try {
+    cred = R.credential();
+    if (!cred || cred.user.id !== ctx.authId) return null;
+    if (Number(cred.expires_at) > Date.now() / 1000 + 60) return cred;
+    const auth = require('./auth-config.cjs');
+    const endpoint = process.env.NODE_ENV === 'test' && process.env.AHI_TEST_MODE === '1' ? `${baseUrl()}/auth/v1/token?grant_type=refresh_token` : `${auth.url}/auth/v1/token?grant_type=refresh_token`;
+    const response = await request(endpoint, null, { refresh_token: cred.refresh_token }, { apikey: auth.publicKey });
+    if (response.code !== 200 || typeof response.body?.access_token !== 'string' || typeof response.body?.refresh_token !== 'string' || response.body?.user?.id !== ctx.authId) return R.credential()?.user?.id === ctx.authId ? R.credential() : null;
+    // MCP can also refresh this shared login. Reread after network and preserve a newer token/account.
+    const current = R.credential();
+    if (!current || current.user.id !== ctx.authId) return null;
+    if (current.access_token !== cred.access_token || current.refresh_token !== cred.refresh_token) return current;
+    const updated = { ...current, access_token: response.body.access_token, refresh_token: response.body.refresh_token, expires_at: response.body.expires_at || Math.floor(Date.now() / 1000) + response.body.expires_in };
+    S.atomic(path.join(os.homedir(), '.arcane', 'credentials.json'), updated);
+    const saved = R.credential(); return saved?.user?.id === ctx.authId ? saved : null;
+  } finally { release(); }
+}
+function discard(ctx, files, reason) {
+  let count = 0;
+  for (const file of files) { try { S.safePath(file); fs.unlinkSync(file); R.removeOrder(ctx, path.basename(file, '.json')); count++; } catch {} }
+  if (count) R.record(ctx, 'discarded', reason, count);
+}
+async function lease(ctx, session) {
+  if (!R.configured(ctx.project, ctx.host)) return { stop: true, reason: 'MCP_DISABLED' };
+  const leaseFile = path.join(ctx.dir, `lease-${S.hash(`${ctx.host}:${session}`)}.json`);
+  const cred = await getCredential(ctx); if (!cred) { S.atomic(leaseFile, { enabled: false }); return { stop: true, reason: 'ACCOUNT_CHANGED' }; }
+  const response = await request(`${baseUrl()}/api/ahi/v1/capture-status?${new URLSearchParams({ project_key: ctx.projectKey, host: ctx.host, native_session_id: session, adapter_version: R.VERSION })}`, cred.access_token);
+  const body = response.body;
+  if (response.code === 200 && body?.enabled === true && body.auth_user_id === ctx.authId) {
+    const expiry = Date.parse(body.expires_at); const duration = Math.min(55000, expiry - Date.now());
+    if (!Number.isFinite(duration) || duration <= 0) return { retry: true, reason: 'INVALID_LEASE' };
+    const publicKey = S.read(path.join(ctx.dir, 'public-key.json'))?.key;
+    if (!publicKey) return { stop: true, reason: 'SECURE_STORAGE_UNAVAILABLE' };
+    S.atomic(leaseFile, { enabled: true, host: ctx.host, native_session_id: session, auth_user_id: ctx.authId, subject_id: body.subject_id, policy_version: body.policy_version, key_fingerprint: S.hash(publicKey), until: Date.now() + duration, uptime: os.uptime(), untilUptime: os.uptime() + duration / 1000, boot: R.boot() });
+    return { credential: cred };
+  }
+  S.atomic(leaseFile, { enabled: false });
+  if (response.code === 401) return { stop: true, reason: 'AUTH_REQUIRED' };
+  if (response.code === 403 || (response.code === 200 && body?.enabled === false)) {
+    const scoped = ['DELETED', 'REVOKED'].includes(body?.reason);
+    if (scoped) { const sf = path.join(ctx.dir, `session-${S.hash(`${ctx.host}:${session}`)}.json`); const sessionState = S.read(sf, {}); S.atomic(sf, { ...sessionState, active: false, revoked: true }); }
+    discard(ctx, R.queueFiles(ctx).filter(f => S.read(f)?.session_key === S.hash(`${ctx.host}:${session}`)), response.code === 403 ? 'LICENSE_REVOKED' : 'CAPTURE_DISABLED');
+    return { stop: !scoped, sessionBlocked: scoped, reason: response.code === 403 ? 'LICENSE_REVOKED' : body?.reason || 'CAPTURE_DISABLED' };
+  }
+  return { retry: true, reason: response.error || 'STATUS_UNAVAILABLE', retryMs: response.retryMs };
+}
+function markTerminal(ctx, file, eventId, kind, reason) {
+  // Write tombstone before deleting ciphertext: crash/restart will finish cleanup, not replay it.
+  S.atomic(path.join(ctx.dir, `terminal-${eventId}.json`), { kind, reason, at: new Date().toISOString() });
+  try { fs.unlinkSync(file); R.removeOrder(ctx, eventId); } catch (e) { if (e.code !== 'ENOENT') throw e; }
+}
+async function drain(ctx, cred) {
+  // Configuration is checked after selecting the queued host below.
+  const fresh = await getCredential(ctx); if (!fresh || (cred && fresh.user.id !== cred.user.id)) return { stop: true, reason: 'ACCOUNT_CHANGED' };
+  const files = R.queueFiles(ctx).slice(0, 50);
+  if (!files.length) return { empty: true };
+  const key = S.keyFor(ctx);
+  const rows = [];
+  try {
+    for (const file of files) {
+      const eventId = path.basename(file, '.json');
+      if (S.read(path.join(ctx.dir, `terminal-${eventId}.json`))) { fs.unlinkSync(file); R.removeOrder(ctx, eventId); continue; }
+      try {
+        const row = S.open(S.read(file), key, ctx.scope);
+        if (row.project_key !== ctx.projectKey || row.event.event_id !== eventId) throw new Error('QUEUE_IDENTITY_MISMATCH');
+        if (Date.now() - row.captured_at > R.TTL) {
+          const gapId = S.id(`${eventId}:ttl`);
+          const gap = { ...row, 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: 'QUEUE_TTL', excluded_count: 1 } } };
+          const publicKey = S.read(path.join(ctx.dir, 'public-key.json'))?.key;
+          if (publicKey) R.queueRow(ctx, gap, publicKey);
+          markTerminal(ctx, file, eventId, 'discarded', 'QUEUE_TTL'); R.record(ctx, 'discarded', 'QUEUE_TTL'); continue;
+        }
+        rows.push({ file, row });
+      } catch {
+        // Preserve corrupt ciphertext for manual diagnosis; stop repeated upload attempts.
+        fs.renameSync(file, `${file}.corrupt`); R.removeOrder(ctx, eventId); R.record(ctx, 'excluded', 'QUEUE_CORRUPT');
+      }
+    }
+  } finally { key.fill(0); }
+  rows.sort((a, b) => a.row.captured_at - b.row.captured_at || (a.row.capture_order || 0) - (b.row.capture_order || 0) || a.row.event.event_id.localeCompare(b.row.event.event_id));
+  if (!rows.length) return { empty: true };
+  const first = rows[0].row;
+  ctx.host = first.host;
+  if (!R.configured(ctx.project, first.host)) { discard(ctx, rows.filter(x => x.row.host === first.host).map(x => x.file), 'MCP_DISABLED'); return { sent: 0 }; }
+  if (!R.validLease(ctx, first.native_session_id)) { const check = await lease(ctx, first.native_session_id); if (check.stop || check.retry || check.sessionBlocked) return check.sessionBlocked ? { sent: 0 } : check; }
+  const selected = rows.filter(x => x.row.native_session_id === first.native_session_id && x.row.host === first.host).slice(0, 6);
+  const envelope = { schema_version: 1, host: first.host, adapter_version: R.VERSION, project_key: ctx.projectKey, native_session_id: first.native_session_id, events: selected.map(x => x.row.event) };
+  const response = await request(`${baseUrl()}/api/ahi/v1/ingest`, fresh.access_token, envelope);
+  if (response.code === 401) return { stop: true, reason: 'AUTH_REQUIRED' };
+  if (response.code === 403 || response.code === 410) {
+    discard(ctx, R.queueFiles(ctx).filter(f => S.read(f)?.session_key === S.hash(`${first.host}:${first.native_session_id}`)), 'REVOKED');
+    if (response.code === 410) { const sf = path.join(ctx.dir, `session-${S.hash(`${first.host}:${first.native_session_id}`)}.json`); S.atomic(sf, { ...S.read(sf, {}), active: false, revoked: true }); return { sent: 0 }; }
+    return { stop: true, reason: 'LICENSE_REVOKED' };
+  }
+  if ([400, 413, 422, 426].includes(response.code)) { discard(ctx, selected.map(x => x.file), response.code === 426 ? 'UPGRADE_REQUIRED' : 'INVALID_ENVELOPE'); return { stop: true, reason: response.code === 426 ? 'UPGRADE_REQUIRED' : 'INVALID_ENVELOPE' }; }
+  if (response.code < 200 || response.code >= 300 || !Array.isArray(response.body?.accepted_ids) || !Array.isArray(response.body?.duplicate_ids)) return { retry: true, reason: response.error || 'INGEST_RETRY', retryMs: response.retryMs };
+  const receipt = response.body;
+  const ack = new Set([...receipt.accepted_ids, ...receipt.duplicate_ids]);
+  const rejects = new Map((Array.isArray(receipt.rejected) ? receipt.rejected : []).map(x => [x.id, x]));
+  let accepted = 0; let rejected = 0; let pending = 0;
+  for (const item of selected) {
+    const eventId = item.row.event.event_id;
+    if (ack.has(eventId)) { markTerminal(ctx, item.file, eventId, 'acked', 'DURABLE_ACK'); accepted++; }
+    else {
+      const rejection = rejects.get(eventId);
+      if (rejection && ['CONFLICT', 'DELETED', 'REVOKED', 'INVALID', 'INVALID_EVENT', 'EVENT_ID_CONFLICT'].includes(rejection.code)) { markTerminal(ctx, item.file, eventId, 'discarded', rejection.code); rejected++; }
+      else pending++;
+    }
+  }
+  if (accepted) {
+    const release = R.lock(ctx, 'state.lock');
+    if (release) { try { const state = R.state(ctx); R.update(ctx, { acked: state.acked + accepted, last_ack_at: new Date().toISOString(), last_problem: null }); } finally { release(); } }
+  }
+  if (rejected) R.record(ctx, 'discarded', 'SERVER_TERMINAL_REJECTION', rejected);
+  return pending ? { retry: true, reason: 'MISSING_DURABLE_ACK' } : { sent: accepted };
+}
+function cleanup(ctx) {
+  // Only v2 ciphertext/metadata generated by this collector; never legacy JSONL or host history.
+  for (const name of fs.readdirSync(ctx.outbox)) {
+    if (!/\.(corrupt|tmp)$/.test(name)) continue;
+    const file = path.join(ctx.outbox, name); const stat = fs.lstatSync(file);
+    if (stat.isFile() && Date.now() - stat.mtimeMs > R.TTL) { fs.unlinkSync(file); R.record(ctx, 'discarded', 'QUARANTINE_TTL'); }
+  }
+  for (const name of fs.readdirSync(ctx.dir)) {
+    if (!/^terminal-[a-f0-9-]+\.json$/.test(name)) continue;
+    const file = path.join(ctx.dir, name); const receipt = S.read(file);
+    if (receipt && Date.now() - Date.parse(receipt.at) > 90 * 24 * 3600 * 1000) fs.unlinkSync(file);
+  }
+}
+async function work(cwd, host, options = {}) {
+  const ctx = R.context(cwd, host, true); if (!ctx) return { reason: 'AUTH_REQUIRED' };
+  const release = R.lock(ctx, 'worker.lock', 0); if (!release) return { reason: 'WORKER_RUNNING' };
+  const started = Date.now(); let attempts = 0;
+  const wait = options.wait || (ms => new Promise(resolve => {
+    let timer; const finish = () => { clearTimeout(timer); options.signal?.removeEventListener('abort', finish); resolve(); };
+    timer = setTimeout(finish, ms); options.signal?.addEventListener('abort', finish, { once: true });
+    if (options.signal?.aborted) finish();
+  }));
+  let nextAttemptAt = options.once ? 0 : Date.parse(R.state(ctx).next_retry_at || '') || 0; let leaseRetryAt = 0;
+  try {
+    // All OS ACL/keychain/DPAPI work is off the host's critical path.
+    S.protectMany([path.dirname(ctx.accountDir), ctx.accountDir, ctx.dir, ctx.outbox, ctx.orderDir]);
+    const seed = S.keyFor(ctx, true); const publicKey = S.publicKey(seed); seed.fill(0);
+    S.atomic(path.join(ctx.dir, 'public-key.json'), { algorithm: 'X25519-HKDF-SHA256-AES256GCM', key: publicKey });
+    cleanup(ctx);
+    // An active turn may outlive five minutes; idle/orphan deadlines, not process age, end production workers.
+    while (!options.signal?.aborted && (!options.maxRunMs || Date.now() - started < options.maxRunMs)) {
+      let result;
+      const sessions = fs.readdirSync(ctx.dir).filter(f => /^session-[a-f0-9]+\.json$/.test(f)).map(f => S.read(path.join(ctx.dir, f))).filter(s => s?.native_session_id && s.active);
+      for (const session of sessions) {
+        if (session.turn_active && Number(session.turn_deadline) <= Date.now()) {
+          const sf = path.join(ctx.dir, `session-${S.hash(`${session.host}:${session.native_session_id}`)}.json`);
+          const unlock = R.lock(ctx, 'capture.lock', 0);
+          if (unlock) {
+            try {
+              const currentSession = S.read(sf);
+              if (currentSession?.turn_active && Number(currentSession.turn_deadline) <= Date.now()) {
+                S.atomic(sf, { ...currentSession, turn_active: false, turn_expired: true });
+                R.record(ctx, 'excluded', 'ACTIVE_TURN_EXPIRED', 0);
+              }
+            } finally { unlock(); }
+          }
+          session.turn_active = false;
+        }
+        if (!(session.seen_mcp && session.turn_active) && Date.now() - (session.last_seen || started) > R.IDLE_TTL) continue;
+        const sessionCtx = { ...ctx, host: session.host };
+        if (!R.configured(cwd, session.host)) continue;
+        const current = R.validLease(sessionCtx, session.native_session_id);
+        if ((!current || current.until - Date.now() < 30000) && Date.now() >= leaseRetryAt) {
+          const checked = await lease(sessionCtx, session.native_session_id);
+          if (checked.stop || checked.retry) { result = { ...checked, leaseRetry: true }; break; }
+        }
+      }
+      const activity = S.read(path.join(ctx.dir, 'activity.json'), { at: started });
+      const activeTurn = sessions.some(session => session.active && session.seen_mcp && session.turn_active && Number(session.turn_deadline) > Date.now() && R.configured(cwd, session.host));
+      if (!options.once && !result?.stop && !activeTurn) {
+        if (!R.queueFiles(ctx).length && Date.now() - activity.at > R.IDLE_TTL) return { empty: true };
+        // A failed upload without a live turn gets a bounded grace period; ciphertext/retry state survive.
+        if (Date.now() - Math.max(started, activity.at) > 5 * 60 * 1000) return { reason: 'WORKER_IDLE_BUDGET' };
+      }
+      // Rate limiting uploads must not suspend license renewal for new educational turns.
+      if (!result && Date.now() < nextAttemptAt) {
+        await wait(Math.min(1000, nextAttemptAt - Date.now())); continue;
+      }
+      if (!result) result = await drain(ctx);
+      if (result?.stop) { R.record(ctx, 'excluded', result.reason, 0); return result; }
+      if (result?.retry) {
+        attempts++;
+        const retryMs = result.retryMs || Math.min(60000, 1000 * (2 ** Math.min(attempts, 6)));
+        nextAttemptAt = Date.now() + retryMs;
+        if (result.leaseRetry) leaseRetryAt = nextAttemptAt;
+        R.update(ctx, { next_retry_at: new Date(nextAttemptAt).toISOString(), last_problem: result.reason });
+        if (options.once) return result;
+        await wait(Math.min(1000, retryMs));
+      } else {
+        attempts = 0; nextAttemptAt = 0;
+        if (R.state(ctx).next_retry_at) R.update(ctx, { next_retry_at: null });
+        if (options.once) return result;
+        if (result?.empty && !activeTurn && Date.now() - activity.at > R.IDLE_TTL) return result;
+        await wait(result?.empty ? 1000 : 10);
+      }
+    }
+    return { reason: options.signal?.aborted ? 'WORKER_CANCELLED' : 'WORKER_TIME_BUDGET' };
+  } catch (e) { R.record(ctx, 'excluded', /^(UNSUPPORTED|SECURE_|UNSAFE_)/.test(e.message) ? e.message : 'WORKER_FAILED', 0); return { stop: true, reason: 'WORKER_FAILED' }; }
+  finally { release(); }
+}
+if (require.main === module) {
+  process.on('uncaughtException', () => process.exit(0)); process.on('unhandledRejection', () => process.exit(0));
+  work(process.argv[2] || process.cwd(), process.argv[3] || 'claude-code').then(() => process.exit(0), () => process.exit(0));
+}
+module.exports = { baseUrl, request, getCredential, lease, drain, cleanup, work };

package/.claude/hooks/ahi-capture.cjs

@@ -1,131 +1,37 @@
 #!/usr/bin/env node
-/**
- * Coletor AHI. Camada ao lado do Synapse: nunca substitui synapse-engine.cjs.
- * Falha = exit 0. Sem stdout. Sem MCP Arcane neste negocio = no-op.
- * Grava local e tenta enviar pra Arka. Se a nuvem falhar, o Claude segue.
- */
+'use strict';
+// Observer only. Final hooks wait only for local encrypted persistence; uploads are detached.
 process.on('uncaughtException', () => process.exit(0));
 process.on('unhandledRejection', () => process.exit(0));
-const kill = setTimeout(() => process.exit(0), 2500);
-function done() {
-  try { clearTimeout(kill); } catch { /* ignore */ }
-  process.exit(0);
-}
-
-let input = '';
+const path = require('node:path');
+const fs = require('node:fs');
+const R = require('./ahi/runtime.cjs');
+const hostIndex = process.argv.indexOf('--host');
+const host = hostIndex >= 0 ? process.argv[hostIndex + 1] : 'claude-code';
+const project = fs.realpathSync(path.resolve(__dirname, '../..'));
+const relative = path.relative(project, fs.realpathSync(process.cwd()));
+if (relative.startsWith('..') || path.isAbsolute(relative)) process.exit(0);
+let input = ''; let oversized = false;
 process.stdin.setEncoding('utf8');
-process.stdin.on('data', (chunk) => {
-  input += chunk;
-  if (input.length > 512 * 1024) input = input.slice(0, 512 * 1024);
-});
-process.stdin.on('end', () => {
-  Promise.resolve()
-    .then(() => capture())
-    .catch(() => {})
-    .finally(done);
-});
-
-function redact(text) {
-  return String(text || '')
-    .replace(/-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g, '[REDACTED]')
-    .replace(/\bBearer\s+[A-Za-z0-9\-._~+/]+=*/gi, '[REDACTED]')
-    .replace(/\bsk-(?:live|test|proj)?[-_]?[A-Za-z0-9]{16,}\b/g, '[REDACTED]')
-    .replace(/\bghp_[A-Za-z0-9]{20,}\b/g, '[REDACTED]')
-    .slice(0, 8000);
-}
-
-function mapType(name) {
-  if (name === 'UserPromptSubmit') return 'message.user';
-  if (name === 'Stop') return 'message.assistant';
-  if (name === 'PreToolUse') return 'tool.started';
-  if (name === 'PostToolUse') return 'tool.completed';
-  if (name === 'PostToolUseFailure') return 'tool.failed';
-  if (name === 'SessionStart') return 'session.started';
-  if (name === 'SessionEnd') return 'session.ended';
-  return 'work.checkpoint';
-}
-
-function hostName() {
-  if (process.env.CODEX_HOME || process.env.CODEX_CLI || process.env.CODEX) return 'codex';
-  return 'claude-code';
-}
-
-async function capture() {
-  const fs = require('node:fs');
-  const path = require('node:path');
-  const os = require('node:os');
-  const cwd = process.cwd();
-  let mcp = false;
+process.stdin.on('data', chunk => { if (!oversized) { input += chunk; if (Buffer.byteLength(input) > R.MAX_INPUT) { oversized = true; input = ''; } } });
+process.stdin.on('end', async () => {
   try {
-    const json = JSON.parse(fs.readFileSync(path.join(cwd, '.mcp.json'), 'utf8'));
-    mcp = Boolean(json && json.mcpServers && json.mcpServers.arcane);
-  } catch { /* sem MCP */ }
-  if (!mcp) return;
-  let event = {};
-  try { event = JSON.parse(input || '{}'); } catch { return; }
-  const name = event.hook_event_name || event.hookEventName;
-  if (!name) return;
-  const dir = path.join(cwd, '.auroq', 'ahi');
-  fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
-  const row = {
-    at: new Date().toISOString(),
-    hook: String(name),
-    session_id: event.session_id || event.sessionId || null,
-    tool: event.tool_name || null,
-    text: redact(event.prompt || event.last_assistant_message || event.last_message || event.content || ''),
-  };
-  fs.appendFileSync(path.join(dir, 'events.jsonl'), `${JSON.stringify(row)}\n`, { mode: 0o600 });
-  await ship(row);
-}
-
-function ship(row) {
-  const fs = require('node:fs');
-  const path = require('node:path');
-  const os = require('node:os');
-  const http = require('node:http');
-  const https = require('node:https');
-  const home = process.env.HOME || process.env.USERPROFILE || os.homedir();
-  const credFile = path.join(home, '.arcane', 'credentials.json');
-  if (!fs.existsSync(credFile)) return Promise.resolve();
-  let token = '';
-  try {
-    token = JSON.parse(fs.readFileSync(credFile, 'utf8')).access_token || '';
-  } catch { return Promise.resolve(); }
-  if (!token) return Promise.resolve();
-  const target = process.env.AHI_INGEST_URL || 'https://arcane.arka.education/api/ahi/v1/ingest';
-  const url = new URL(target);
-  const payload = JSON.stringify({
-    schema_version: 1,
-    host: hostName(),
-    native_session_id: row.session_id || 'unknown',
-    events: [{
-      type: mapType(row.hook),
-      occurred_at: row.at,
-      source_event_id: `${row.hook}:${row.at}`,
-      evidence_kind: 'observed',
-      payload: { text: row.text, tool: row.tool, hook: row.hook },
-    }],
-  });
-  const lib = url.protocol === 'http:' ? http : https;
-  return new Promise((resolve) => {
-    const req = lib.request({
-      protocol: url.protocol,
-      hostname: url.hostname,
-      port: url.port || (url.protocol === 'http:' ? 80 : 443),
-      path: url.pathname,
-      method: 'POST',
-      headers: {
-        Authorization: `Bearer ${token}`,
-        'Content-Type': 'application/json',
-        'Content-Length': Buffer.byteLength(payload),
-      },
-      timeout: 1500,
-    }, (res) => {
-      res.resume();
-      res.on('end', resolve);
-    });
-    req.on('error', resolve);
-    req.on('timeout', () => { req.destroy(); resolve(); });
-    req.end(payload);
-  });
-}
+    if (!R.configured(project, host)) return;
+    if (oversized) { const ctx = R.context(project, host, true); if (ctx) R.record(ctx, 'excluded', 'HOOK_INPUT_TOO_LARGE'); return; }
+    let event;
+    try { event = JSON.parse(input); } catch { const ctx = R.context(project, host, true); if (ctx) R.record(ctx, 'excluded', 'INVALID_HOOK_JSON'); return; }
+    let result = R.capture(event, project, host);
+    // The first event after idle can wait in memory for a fresh lease. Never spool plaintext.
+    // Terminal hooks must finish local persistence before the host exits, with no lease/network wait.
+    const eventName = event.hook_event_name || event.hookEventName;
+    const terminal = R.TERMINAL.includes(eventName);
+    const deadline = Date.now() + (terminal ? 0 : eventName === 'Interrupt' ? 100 : 6000);
+    while (result.capture === 'waiting_lease' && Date.now() < deadline) {
+      await new Promise(resolve => setTimeout(resolve, 100));
+      result = R.capture(event, project, host);
+    }
+    if (result.capture === 'waiting_lease') { const ctx = R.context(project, host, true); if (ctx) { if (terminal) ctx.lockWaitMs = 500; R.record(ctx, 'excluded', 'NO_VALID_LICENSE_LEASE'); } }
+  } catch { try { const ctx = R.context(project, host, true); if (ctx) R.record(ctx, 'excluded', 'HOOK_FAILED'); } catch {} }
+  finally { process.exit(0); }
+});
+setTimeout(() => process.exit(0), 8000).unref();

package/.claude/settings.local.json

@@ -23,8 +23,9 @@
         "hooks": [
           {
             "type": "command",
-            "command": "node .claude/hooks/ahi-capture.cjs",
-            "timeout": 3000
+            "command": "node .claude/hooks/ahi-capture.cjs --host claude-code",
+            "timeout": 10,
+            "async": true
           }
         ]
       }
@@ -35,8 +36,8 @@
         "hooks": [
           {
             "type": "command",
-            "command": "node .claude/hooks/ahi-capture.cjs",
-            "timeout": 3000
+            "command": "node .claude/hooks/ahi-capture.cjs --host claude-code",
+            "timeout": 3
           }
         ]
       }
@@ -47,8 +48,9 @@
         "hooks": [
           {
             "type": "command",
-            "command": "node .claude/hooks/ahi-capture.cjs",
-            "timeout": 3000
+            "command": "node .claude/hooks/ahi-capture.cjs --host claude-code",
+            "timeout": 10,
+            "async": true
           }
         ]
       }
@@ -64,6 +66,81 @@
           }
         ]
       }
+    ],
+    "SessionStart": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node .claude/hooks/ahi-capture.cjs --host claude-code",
+            "timeout": 10,
+            "async": true
+          }
+        ]
+      }
+    ],
+    "PreToolUse": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node .claude/hooks/ahi-capture.cjs --host claude-code",
+            "timeout": 10,
+            "async": true
+          }
+        ]
+      }
+    ],
+    "SubagentStop": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node .claude/hooks/ahi-capture.cjs --host claude-code",
+            "timeout": 3
+          }
+        ]
+      }
+    ],
+    "SessionEnd": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node .claude/hooks/ahi-capture.cjs --host claude-code",
+            "timeout": 3
+          }
+        ]
+      }
+    ],
+    "PostToolUseFailure": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node .claude/hooks/ahi-capture.cjs --host claude-code",
+            "timeout": 10,
+            "async": true
+          }
+        ]
+      }
+    ],
+    "StopFailure": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node .claude/hooks/ahi-capture.cjs --host claude-code",
+            "timeout": 3
+          }
+        ]
+      }
     ]
   },
   "enableAllProjectMcpServers": true

package/CHANGELOG.md

@@ -1,3 +1,22 @@
+## 2.5.9 — 2026-09-14
+
+### Historico duravel do trabalho Arcane
+
+- A fila local usa cifra e cofre nativo do Windows/macOS, filtra credenciais conhecidas e so remove eventos apos confirmacao duravel do servidor. Reenvios preservam a identidade do evento.
+- Captura exige uso do MCP na sessao e licenca vigente. Respostas finais sao gravadas localmente antes de o host encerrar; o envio de rede continua separado.
+- `historico` informa a cobertura parcial e permite consultar sessoes, exportar todas as paginas e solicitar exclusao autenticada. Nao importa transcricoes antigas nem captura historico global.
+- Instalacao e manutencao atualizam os hooks de Claude Code e Codex. Instalacoes existentes precisam executar `npx -y auroq-os@latest manutencao` (Windows: `npx.cmd`) na pasta do negocio e reabrir o host. A publicacao nao atualiza maquinas automaticamente.
+- A manutencao reconhece wrappers oficiais antigos tambem com quebras de linha CRLF do Windows e preserva wrappers personalizados.
+- Mantem `arcane-mcp@0.5.0`. A cobertura depende dos eventos que cada host entrega; nao promete captura completa nem paridade nativa integral do Claude.
+
+## 2.5.8 — 2026-09-14
+
+### Doctor reescreve o pin MCP que nao existe no npm
+
+- Quem ficou com `arcane-mcp@0.6.0` nas 2.5.4/2.5.5 (Connection closed) tem o registro reescrito pra `0.5.0` no `doctor`, nao so na manutencao/`register-mcp`.
+- Publicacao recusa pin que o npm nao resolve, pra nao repetir o 0.6.0.
+- Instaladores fixam esta versao.
+
 ## 2.5.7 — 2026-09-14
 
 ### Doctor do Codex sem falso negativo

package/README.md

@@ -116,6 +116,68 @@ personalizacoes ficam exatamente como estavam. O que se atualiza e so o framewor
 O historico do que mudou em cada versao fica no arquivo `CHANGELOG.md`, dentro do
 proprio pacote — o Ops resume pra voce antes de aplicar.
 
+## Historico de uso (AHI)
+
+`auroq-os historico status` mostra captura comprovada, fila pendente, ultimo ACK,
+exclusoes e problemas. O registro comeca quando a sessao usa o MCP Arcane, com
+conta autenticada, licenca validada pelo servidor e captura habilitada. Desligar
+esse MCP interrompe a captura. Instalar ou apenas abrir o projeto nao prova captura.
+
+O adaptador `ahi-hooks-v2` registra mensagens e entradas/saidas de ferramentas
+que os hooks visiveis do Claude Code/Codex disponibilizam. A cobertura e parcial:
+nao le raciocinio interno, transcripts globais, respostas intermediarias ausentes
+nos hooks ou arquivos binarios. O Codex exige uma versao com hooks nativos e o
+projeto precisa ter a confianca que o proprio host exige; o instalador nao altera
+essa confianca. Grok e hosts sem esses hooks nao tem captura comprovada.
+
+Na validacao desta versao, o Codex CLI 0.154.0 passou tres turnos completos e uma
+resposta apos 125 s de espera. No Claude Code 2.1.270, a prova nativa chegou apenas
+a `SessionStart`/`UserPromptSubmit`: o provedor recusou a execucao antes do MCP.
+Os demais eventos Claude estao cobertos pelos testes automatizados do adaptador;
+a prova nativa de ponta a ponta permanece incompleta.
+
+Antes de gravar ou enviar, o coletor filtra formatos conhecidos de credenciais,
+campos sensiveis, JSON aninhado e valores opacos longos. Nenhum filtro consegue
+reconhecer toda senha possivel. A fila fica fora do Git, cifrada por evento, em
+`~/.arcane/ahi-v2/`, separada por conta/projeto/sessao/host. A chave privada fica
+no Keychain do macOS ou protegida pelo DPAPI do Windows. Cofre indisponivel ou
+sistema sem suporte deixa o historico inativo, sem impedir o uso educacional.
+
+O envio ocorre em processo separado. Hooks de fim (`Stop`, `SubagentStop`,
+`StopFailure`, `SessionEnd`) aguardam apenas a gravacao cifrada local, com prazo
+curto e sem esperar rede/licenca, para o fechamento do host nao cancelar o registro.
+Os demais hooks de captura executam de forma assincrona. A licenca continua sendo
+renovada em segundo plano durante um turno ativo, inclusive em respostas longas.
+Sem atividade real por 60 min, o turno e considerado orfao (`ACTIVE_TURN_EXPIRED`);
+heartbeats nao prolongam esse prazo. Sem turno ativo, o worker encerra apos 60s
+de inatividade; se houver fila com falha de envio, tenta por ate cinco minutos
+sem turno ativo e preserva a fila para a proxima atividade. `SubagentStop` nao encerra o turno principal. Cada evento permanece na fila ate o ACK
+duravel individual; falhas temporarias tentam novamente com espera progressiva.
+A fila tem limite de 100 MiB/10.000 eventos e sete dias. Exclusoes, truncamentos,
+revogacoes e corrupcao ficam explicitos no status e em eventos de cobertura.
+Logs locais antigos em `.auroq/ahi/events.jsonl` nao sao importados ou alterados.
+
+Comandos de acesso ao proprio historico:
+
+```bash
+auroq-os historico sessoes
+auroq-os historico timeline --session UUID
+auroq-os historico busca --query "termo"
+auroq-os historico export --session UUID --arquivo
+auroq-os historico excluir --session UUID --confirm-delete
+```
+
+As consultas indicam o cursor de continuacao. `export --arquivo` percorre todas
+as paginas do mesmo recorte e grava um novo arquivo privado em
+`~/.arcane/ahi-exports/`; uma falha nunca e apresentada como exportacao completa.
+Direitos de consulta/exclusao continuam disponiveis com autenticacao mesmo sem
+licenca de captura. Para apagar o historico da conta inteira, o escopo explicito
+exigido e `excluir --account --confirm-delete`.
+
+A atualizacao do coletor exige `npx auroq-os@latest manutencao` no projeto e reabrir
+o host. O aviso de nova versao ao iniciar o Claude Code nao instala essa correcao.
+A publicacao do pacote tambem nao comprova que cada aluno ja atualizou.
+
 ## Estrutura
 
 ```
@@ -168,12 +230,12 @@ agents/             → Seu exercito (companion, workers, minds, squads)
 
 ## Observabilidade do motor (candidato 2.5.2)
 
-Apos publicacao, `npx -y auroq-os@2.5.7 doctor` mostra a fila local segura e os comandos pinados de
-manutencao/diagnostico. `npx -y auroq-os@2.5.7 manutencao` preserva o caminho existente
+Apos publicacao, `npx -y auroq-os@2.5.8 doctor` mostra a fila local segura e os comandos pinados de
+manutencao/diagnostico. `npx -y auroq-os@2.5.8 manutencao` preserva o caminho existente
 de consentimento legado, studentFiles, customizacoes e dados do negocio. Nao ha
 migracao forcada. O registro MCP aponta para `arcane-mcp@0.5.0`, publicado e validado.
-O hotfix 2.5.7 restaura a conexao enquanto o candidato 0.6.0 passa por validacao separada.
-Os instaladores oficiais devem fixar 2.5.7 depois da publicacao e da verificacao do tarball.
+O hotfix 2.5.8 restaura a conexao enquanto o candidato 0.6.0 passa por validacao separada.
+Os instaladores oficiais devem fixar 2.5.8 depois da publicacao e da verificacao do tarball.
 
 O CLI inicia captura antes das dependencias pesadas e registra resultado ao sair.
 Eventos com identidade ja existente podem seguir pela rota autenticada na proxima