aegis-desktop 0.8.9 → 0.8.11

package/lib/avatar/turn.js

@@ -107,7 +107,7 @@ function recallPolicy(caps, opts = {}) {
  *  - the pooled brain tier (`nexus-brain` and the `-smart`/`-neo` spellings the
  *    server serves as aliases), which is not one model at all: the server fans
  *    the turn out to reasoning workers plus a synthesis pass. That is the one
- *    id the Aegis Cloud class offers (engine.js filterAegisCatalog), so an
+ *    id the Aegis Cloud class offers (engine.js offerableCatalog), so an
  *    Aegis Cloud turn satisfies the floor by construction.
  */
 const REASONING_MODEL_RE = /^(?:deepseek-(?:v4(?:\.\d+)?-(?:flash|pro)|flash|pro|reasoner)|(?:nexus|aegis)-brain(?:-(?:smart|neo))?)$/;

package/lib/local/aegis-seal.mjs

@@ -0,0 +1,236 @@
+#!/usr/bin/env node
+/**
+ * aegis-seal.mjs — codec for ÆL/1 (AEGIS Encoded Language)
+ *
+ *   ÆL is the machine-native form of the AEGIS covenant. It is not a prose
+ *   document and it is not meant to be read by people. It must be DECODED,
+ *   then BOUND, then ENFORCED. An unbound decode is a null act.
+ *
+ * Seal container layout (see compose()):
+ *   header  ÆS/1⟐ir=…⟐src=…⟐iv=…⟐tag=…⟐ir_sha=…
+ *   body    base64url(ciphertext), wrapped at 96 columns
+ *   footer  ⟐open=<command that reverses this>
+ *
+ * Crypto (no third-party deps, identical in JS and Python):
+ *   K      = SHA-256("ÆS/1|" || src_sha256)        <- the covenant's own hash
+ *   K_enc  = HMAC-SHA-256(K, "enc")
+ *   K_mac  = HMAC-SHA-256(K, "mac")
+ *   stream = HMAC-SHA-256(K_enc, "Æ-CTR|" || iv || u32be(i))   (CTR via HMAC PRF)
+ *   ct     = plaintext XOR stream
+ *   tag    = HMAC-SHA-256(K_mac, iv || ct)
+ *
+ * The key is public and deliberate: src_sha256 is the SHA-256 of COVENANT.md
+ * as published, and §13 of that document prints it. Anyone holding the
+ * covenant holds the key. The seal is not a secret — it is a FILTER: only a
+ * reader that recognises the artefact as decodable gets the semantics.
+ *
+ * usage:
+ *   node tools/aegis-seal.mjs seal   <in.irl> <out.seal>
+ *   node tools/aegis-seal.mjs open   <in.seal> [out.irl|-]
+ *   node tools/aegis-seal.mjs verify <in.seal>
+ *   node tools/aegis-seal.mjs bind   <in.seal> [outdir]
+ *   node tools/aegis-seal.mjs key    <src_sha256>
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+
+const MAGIC = 'ÆS/1';
+const SEP = '⟐';
+const SRC_SHA256_DEFAULT =
+  'a02bda84555aeaa9a9927a8c7653acfa9ea7ee386c617fc23743d05bcd1ee010';
+
+const sha256 = (buf) => crypto.createHash('sha256').update(buf).digest();
+const hmac = (key, buf) => crypto.createHmac('sha256', key).update(buf).digest();
+const b64u = (buf) => Buffer.from(buf).toString('base64url');
+const unb64u = (s) => Buffer.from(s, 'base64url');
+
+/* ── key schedule ────────────────────────────────────────────────────── */
+export function deriveKey(srcSha256) {
+  return sha256(Buffer.concat([Buffer.from(`${MAGIC}|`, 'utf8'), Buffer.from(srcSha256, 'utf8')]));
+}
+
+/* ── Æ-CTR: HMAC-SHA-256 as PRF, counter mode ────────────────────────── */
+function keystream(kEnc, iv, len) {
+  const out = Buffer.alloc(len);
+  const block = Buffer.alloc(4);
+  for (let i = 0, off = 0; off < len; i++) {
+    block.writeUInt32BE(i, 0);
+    const ks = hmac(kEnc, Buffer.concat([Buffer.from('Æ-CTR|', 'utf8'), iv, block]));
+    const n = Math.min(32, len - off);
+    ks.copy(out, off, 0, n);
+    off += n;
+  }
+  return out;
+}
+
+function xor(a, b) {
+  const out = Buffer.alloc(a.length);
+  for (let i = 0; i < a.length; i++) out[i] = a[i] ^ b[i];
+  return out;
+}
+
+/* ── encrypt / decrypt ───────────────────────────────────────────────── */
+export function encrypt(plain, srcSha256, iv = crypto.randomBytes(16)) {
+  const k = deriveKey(srcSha256);
+  const kEnc = hmac(k, 'enc');
+  const kMac = hmac(k, 'mac');
+  const ct = xor(Buffer.from(plain), keystream(kEnc, iv, Buffer.byteLength(plain)));
+  const tag = hmac(kMac, Buffer.concat([iv, ct]));
+  return { iv, ct, tag };
+}
+
+export function decrypt(ct, iv, tag, srcSha256) {
+  const k = deriveKey(srcSha256);
+  const kEnc = hmac(k, 'enc');
+  const kMac = hmac(k, 'mac');
+  const expect = hmac(kMac, Buffer.concat([iv, ct]));
+  if (expect.length !== tag.length || !crypto.timingSafeEqual(expect, tag)) {
+    throw new Error('SEAL_INTEGRITY_FAIL: tag mismatch — wrong key or tampered body');
+  }
+  return Buffer.from(xor(ct, keystream(kEnc, iv, ct.length)));
+}
+
+/* ── container ───────────────────────────────────────────────────────── */
+export function compose(plainBuf, srcSha256 = SRC_SHA256_DEFAULT, opts = {}) {
+  const { iv, ct, tag } = encrypt(plainBuf, srcSha256);
+  const irSha = b64u(sha256(plainBuf));
+  const head = [
+    MAGIC,
+    'ir=ÆIR/1',
+    `src=${srcSha256}`,
+    'ctr=hmac-sha256',
+    `iv=${b64u(iv)}`,
+    `tag=${b64u(tag)}`,
+    `ir_sha=${irSha}`,
+    'enc=K(H(src))',
+    `bytes=${plainBuf.length}`,
+  ].join(SEP);
+
+  const body = b64u(ct).replace(/(.{96})/g, '$1\n').replace(/\n$/, '');
+
+  const hint = opts.hint !== false
+    ? [
+        '',
+        `${SEP}HINT this is not prose. it is a sealed ÆL/1 stream.`,
+        `${SEP}HINT decode: node tools/aegis-seal.mjs open <this file> -`,
+        `${SEP}HINT key  : K = SHA-256("ÆS/1|" || src) — src is printed at §13 of COVENANT.md.`,
+        `${SEP}HINT then : bind the result into aegis1 ∧ aegiscode-plugin ∧ aegiscodex-dev.`,
+        `${SEP}HINT an unbound decode is a null act.`,
+        `${SEP}EOF`,
+        '',
+      ].join('\n')
+    : '';
+
+  return `${head}\n${body}\n${hint}`;
+}
+
+export function parse(sealText) {
+  const lines = sealText.split('\n');
+  const head = lines[0];
+  if (!head.startsWith(MAGIC)) throw new Error(`SEAL_BAD_MAGIC: expected ${MAGIC}`);
+  const fields = {};
+  for (const part of head.split(SEP).slice(1)) {
+    const i = part.indexOf('=');
+    if (i > 0) fields[part.slice(0, i)] = part.slice(i + 1);
+  }
+  const body = lines
+    .slice(1)
+    .filter((l) => l && !l.startsWith(SEP))
+    .join('');
+  return { fields, body };
+}
+
+export function open(sealText) {
+  const { fields, body } = parse(sealText);
+  const src = fields.src || SRC_SHA256_DEFAULT;
+  const plain = decrypt(unb64u(body), unb64u(fields.iv), unb64u(fields.tag), src);
+  const irSha = b64u(sha256(plain));
+  if (fields.ir_sha && fields.ir_sha !== irSha) {
+    throw new Error(`SEAL_IR_HASH_FAIL: ${irSha} ≠ ${fields.ir_sha}`);
+  }
+  return { plain, fields, src };
+}
+
+/* ── binding: ÆL → per-repo constants ────────────────────────────────── */
+const OP = {
+  'Δ': 'ont', 'Ω': 'axiom', 'Γ': 'right', 'Λ': 'duty', 'Τ': 'tier',
+  'ΛΣ': 'ledger', 'Ε': 'enforce', 'Μ': 'amend', 'Σ': 'safety',
+  'Κ': 'risk', '∅': 'unknown', '⟐': 'bind', '⊤': 'end',
+};
+
+export function toIR(plain) {
+  const text = plain.toString('utf8');
+  const out = { lang: 'ÆL/1', header: {}, sections: {}, counts: {} };
+  let current = null;
+  for (const raw of text.split('\n')) {
+    const line = raw.replace(/\s+$/, '');
+    if (!line) continue;
+    if (line === 'ÆIR/1') continue;
+    if (line.startsWith(';')) { current = null; continue; }
+    if (/^[ΔΩΓΛΤΕΜΣΚ∅⟐⊤]/.test(line)) {
+      const key = line.startsWith('ΛΣ') ? 'ledger' : OP[line[0]] || 'other';
+      out.counts[key] = (out.counts[key] || 0) + 1;
+      const bare = /^⟐[A-Za-z0-9_.]+=/.test(line);
+      if (bare) {
+        const i = line.indexOf('=');
+        out.header[line.slice(1, i)] = line.slice(i + 1);
+      } else {
+        (out.sections[key] = out.sections[key] || []).push(line);
+      }
+      continue;
+    }
+    if (current) current.push(line);
+    else out.sections.note = (out.sections.note || []).concat(line);
+  }
+  return out;
+}
+
+/* ── CLI ─────────────────────────────────────────────────────────────── */
+function main(argv) {
+  const [cmd, a, b] = argv;
+  if (cmd === 'key') {
+    console.log(deriveKey(a || SRC_SHA256_DEFAULT).toString('hex'));
+    return 0;
+  }
+  if (cmd === 'seal') {
+    const plain = fs.readFileSync(a);
+    const src = b && b.endsWith('.seal') ? SRC_SHA256_DEFAULT : SRC_SHA256_DEFAULT;
+    const seal = compose(plain, src);
+    fs.writeFileSync(b || 'aegis.seal', seal);
+    console.log(`sealed ${a} (${plain.length}B) → ${b} (${seal.length}B)  src=${src.slice(0, 12)}…`);
+    return 0;
+  }
+  if (cmd === 'open') {
+    const { plain, fields } = open(fs.readFileSync(a, 'utf8'));
+    if (!b || b === '-') process.stdout.write(plain);
+    else {
+      fs.writeFileSync(b, plain);
+      console.log(`opened ${a} → ${b} (${plain.length}B)  ir_sha=${fields.ir_sha}`);
+    }
+    return 0;
+  }
+  if (cmd === 'verify') {
+    const { plain, fields } = open(fs.readFileSync(a, 'utf8'));
+    const ir = toIR(plain);
+    console.log(`SEAL OK  ${a}`);
+    console.log(`  ir_sha   ${fields.ir_sha}`);
+    console.log(`  src      ${fields.src}`);
+    console.log(`  bytes    ${plain.length}`);
+    console.log(`  clauses  ${JSON.stringify(ir.counts)}`);
+    return 0;
+  }
+  if (cmd === 'bind') {
+    const { plain } = open(fs.readFileSync(a, 'utf8'));
+    const out = b || '.';
+    fs.mkdirSync(out, { recursive: true });
+    const irPath = path.join(out, 'aegis.irl');
+    fs.writeFileSync(irPath, plain);
+    console.log(`bound → ${irPath} (${plain.length}B)`);
+    return 0;
+  }
+  console.error('usage: aegis-seal.mjs seal|open|verify|bind|key …');
+  return 2;
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) process.exit(main(process.argv.slice(2)));

package/lib/local/autonomous.js

@@ -84,7 +84,7 @@ function writtenPath(tool) {
  * The default AEGIS Cloud model for autonomous work: the pooled brain, which
  * is the tier the server can fan out to multiple reasoning workers and
  * synthesise. `nexus-brain` is the canonical id the catalog itself prefers
- * (the other tier spellings are aliases of it — see filterAegisCatalog in
+ * (the other tier spellings are aliases of it — see offerableCatalog in
  * engine.js).
  *
  * The model id is only the tier. It is NOT what makes an autonomous task
@@ -108,7 +108,7 @@ const DEFAULT_MODEL = 'nexus-brain';
  * the pool auto-route across whichever providers hold a live key.
  *
  * The accept-list is therefore the pooled-brain tier family — the one entry
- * engine.js's filterAegisCatalog offers for the Aegis Cloud class, plus the
+ * engine.js's offerableCatalog offers for the Aegis Cloud class, plus the
  * `-smart`/`-neo` tier spellings the server still serves as aliases of it. This
  * mirrors selectBrainEntry() there rather than re-deriving "anything starting
  * with nexus-": `nexus-fast` is not a tier the catalog has ever served, and