@vascend/talos 0.1.0

package/dist/vendor/computer-use/package.json

@@ -0,0 +1 @@
+{"type":"commonjs","private":true}

package/dist/vendor/computer-use/rac/atomic-input.js

@@ -0,0 +1,91 @@
+'use strict';
+
+const MAX_OPERATIONS = 12;
+const MAX_TEXT = 4000;
+
+const KEY_ALIASES = Object.freeze({
+  ctrl: 'Ctrl', control: 'Ctrl', shift: 'Shift', alt: 'Alt',
+  space: 'Space', tab: 'Tab', esc: 'Esc', escape: 'Esc',
+  enter: 'Enter', return: 'Enter', backspace: 'Backspace', delete: 'Delete', del: 'Delete',
+  home: 'Home', end: 'End', left: 'ArrowLeft', arrowleft: 'ArrowLeft',
+  up: 'ArrowUp', arrowup: 'ArrowUp', right: 'ArrowRight', arrowright: 'ArrowRight',
+  down: 'ArrowDown', arrowdown: 'ArrowDown',
+});
+
+function normalizeKey(value) {
+  const raw = String(value || '').trim();
+  if (!raw) return null;
+  const alias = KEY_ALIASES[raw.toLowerCase()];
+  if (alias) return alias;
+  if (/^[a-z0-9]$/i.test(raw)) return raw.toUpperCase();
+  return null;
+}
+
+function normalizeShortcut(keys) {
+  const source = Array.isArray(keys)
+    ? keys
+    : String(keys || '').split(/[+\s]+/).filter(Boolean);
+  if (!source.length || source.length > 4) {
+    return { ok: false, code: 'BAD_SHORTCUT', error: 'Una scorciatoia richiede da uno a quattro tasti.' };
+  }
+  const normalized = [];
+  for (const value of source) {
+    const key = normalizeKey(value);
+    if (!key) return { ok: false, code: 'BAD_SHORTCUT', error: `Tasto non ammesso: ${String(value)}` };
+    if (!normalized.includes(key)) normalized.push(key);
+  }
+  return { ok: true, keys: normalized };
+}
+
+function normalizeAtomicOperations(value) {
+  if (!Array.isArray(value) || !value.length || value.length > MAX_OPERATIONS) {
+    return { ok: false, code: 'BAD_OPERATIONS', error: `Servono da 1 a ${MAX_OPERATIONS} operazioni.` };
+  }
+  const operations = [];
+  for (const raw of value) {
+    const type = String(raw && raw.type || '').trim().toLowerCase();
+    if (type === 'shortcut') {
+      const shortcut = normalizeShortcut(raw.keys);
+      if (!shortcut.ok) return shortcut;
+      operations.push({ type, keys: shortcut.keys });
+      continue;
+    }
+    if (type === 'text') {
+      const text = String(raw && raw.text != null ? raw.text : '');
+      if (!text || text.length > MAX_TEXT || /[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F]/.test(text)) {
+        return { ok: false, code: 'BAD_TEXT', error: `Il testo deve contenere da 1 a ${MAX_TEXT} caratteri stampabili.` };
+      }
+      operations.push({ type, text });
+      continue;
+    }
+    if (type === 'mouse') {
+      const dx = Number(raw && raw.dx || 0);
+      const dy = Number(raw && raw.dy || 0);
+      const scroll = Number(raw && raw.scroll || 0);
+      if (![dx, dy, scroll].every(Number.isInteger)
+        || Math.abs(dx) > 1000 || Math.abs(dy) > 1000 || Math.abs(scroll) > 5) {
+        return { ok: false, code: 'BAD_MOUSE', error: 'Mouse fuori range: dx/dy ±1000, scroll ±5.' };
+      }
+      operations.push({ type, dx, dy, scroll });
+      continue;
+    }
+    if (type === 'click') {
+      const button = String(raw && raw.button || 'left').toLowerCase();
+      if (!['left', 'right', 'middle'].includes(button)) {
+        return { ok: false, code: 'BAD_BUTTON', error: 'Pulsante ammesso: left, right o middle.' };
+      }
+      operations.push({ type, button });
+      continue;
+    }
+    return { ok: false, code: 'BAD_OPERATION', error: `Operazione non ammessa: ${type || '(vuota)'}` };
+  }
+  return { ok: true, operations };
+}
+
+module.exports = {
+  MAX_OPERATIONS,
+  MAX_TEXT,
+  normalizeKey,
+  normalizeShortcut,
+  normalizeAtomicOperations,
+};

package/dist/vendor/computer-use/rac/grammatica.js

@@ -0,0 +1,101 @@
+'use strict';
+
+// MCP-RAC — grammatica computer-use v0.1 (spec §6.4).
+//
+// Un'azione e' un blocco:
+//
+//   ACTION <observation_id> ttl=<ms>
+//   <dx> <dy> <scroll> ; K1 ; K2 ; ... ; K6 END
+//
+// Il primo segmento e' il MOVIMENTO (relativo, distribuito sull'orizzonte);
+// i successivi sono KEYSET: l'insieme dei tasti tenuti premuti per 33 ms.
+// `_` e' il keyset vuoto (tutto rilasciato). Le chiavi assenti si rilasciano.
+//
+// La grammatica e' volutamente povera: niente Enter, niente Canc, niente tasto
+// Windows. Non e' una dimenticanza — e' il primo strato di sicurezza (spec §13):
+// le azioni irreversibili non devono essere ESPRIMIBILI nel canale reattivo,
+// prima ancora che vietate da una policy.
+
+const LIMITI = Object.freeze({
+  MOUSE_DELTA: 1000,        // dx, dy in [-1000, 1000]
+  SCROLL: 5,                // scroll in [-5, 5]
+  TASTI_PER_CHUNK: 4,       // spec §13: "max quattro tasti/chunk"
+  CHUNK_PER_AZIONE: 6,      // 6 keyset da 33 ms = orizzonte 200 ms
+  TTL_MASSIMO_MS: 250,      // oltre la lease il chunk non ha senso
+  CHUNK_MS: 33,             // durata nominale di un keyset
+  ORIZZONTE_MS: 200,
+  BUFFER_MASSIMO: 16 * 1024,
+});
+
+// L'alfabeto completo dei tasti ammessi. Un token fuori da qui non e' "un tasto
+// sconosciuto da inoltrare": e' un errore di grammatica che avvelena l'azione.
+const TASTI_INTERNI = (() => {
+  const out = new Set(['Shift', 'Ctrl', 'Alt', 'Space', 'Tab', 'Esc', 'LB', 'RB', 'MB']);
+  for (let c = 65; c <= 90; c += 1) out.add(String.fromCharCode(c)); // A..Z
+  for (let d = 0; d <= 9; d += 1) out.add(String(d));                // 0..9
+  return out;
+})();
+// Un Set congelato resta modificabile tramite add/delete. Esponiamo quindi una
+// fotografia realmente immutabile e teniamo il Set usato dalla validazione
+// chiuso nel modulo.
+const TASTI = Object.freeze([...TASTI_INTERNI].sort());
+
+function interoIn(testo, min, max) {
+  if (!/^-?\d+$/.test(testo)) return null;
+  const n = Number(testo);
+  return n >= min && n <= max ? n : null;
+}
+
+// "ACTION 184 ttl=250" -> { observationId, ttlMs } | { errore }
+function analizzaIntestazione(riga) {
+  const m = /^ACTION\s+(\d+)\s+ttl=(\d+)$/.exec(String(riga || '').trim());
+  if (!m) return { errore: 'intestazione malformata' };
+  const observationNumber = Number(m[1]);
+  const ttlMs = Number(m[2]);
+  if (!Number.isSafeInteger(observationNumber)) return { errore: 'observation_id fuori limite' };
+  if (ttlMs <= 0 || ttlMs > LIMITI.TTL_MASSIMO_MS) {
+    return { errore: `ttl fuori limite (1..${LIMITI.TTL_MASSIMO_MS})` };
+  }
+  return { observationId: m[1], ttlMs };
+}
+
+// "92 0 0" -> { tipo: 'mouse', dx, dy, scroll } | { errore }
+function analizzaMouse(segmento) {
+  const parti = String(segmento || '').trim().split(/\s+/);
+  if (parti.length !== 3) return { errore: 'il movimento vuole esattamente dx dy scroll' };
+  const dx = interoIn(parti[0], -LIMITI.MOUSE_DELTA, LIMITI.MOUSE_DELTA);
+  const dy = interoIn(parti[1], -LIMITI.MOUSE_DELTA, LIMITI.MOUSE_DELTA);
+  const scroll = interoIn(parti[2], -LIMITI.SCROLL, LIMITI.SCROLL);
+  if (dx === null || dy === null || scroll === null) return { errore: 'movimento fuori range' };
+  return { tipo: 'mouse', dx, dy, scroll };
+}
+
+// "Shift W" | "_" -> { tipo: 'keyset', tasti: [...] } | { errore }
+// I tasti si normalizzano ordinati e senza duplicati: {W,Shift} e {Shift,W}
+// sono lo stesso stato fisico, e l'esecutore confronta insiemi.
+function analizzaKeyset(segmento) {
+  const testo = String(segmento || '').trim();
+  if (testo === '_') return { tipo: 'keyset', tasti: [] };
+  if (!testo) return { errore: 'keyset vuoto: usa _ per rilasciare tutti i tasti' };
+  const token = testo.split(/\s+/);
+  if (token.length > LIMITI.TASTI_PER_CHUNK) {
+    return { errore: `piu' di ${LIMITI.TASTI_PER_CHUNK} tasti in un chunk` };
+  }
+  const visti = new Set();
+  for (const t of token) {
+    if (!TASTI_INTERNI.has(t)) return { errore: `tasto fuori alfabeto: ${t}` };
+    visti.add(t);
+  }
+  return { tipo: 'keyset', tasti: [...visti].sort() };
+}
+
+// Serializzazione, per il simulatore e i replay: da azione strutturata al testo
+// che il decoder emetterebbe. Round-trip garantito dai test.
+function serializza(azione) {
+  const testa = `ACTION ${azione.observationId} ttl=${azione.ttlMs}\n`;
+  const mouse = `${azione.mouse.dx} ${azione.mouse.dy} ${azione.mouse.scroll}`;
+  const keyset = azione.keyset.map((k) => (k.length ? k.join(' ') : '_'));
+  return testa + [mouse, ...keyset].join(' ; ') + ' ;\nEND';
+}
+
+module.exports = { LIMITI, TASTI, analizzaIntestazione, analizzaMouse, analizzaKeyset, serializza };

package/dist/vendor/computer-use/rac/parser.js

@@ -0,0 +1,185 @@
+'use strict';
+
+// Parser incrementale MCP-RAC. L'unica uscita eseguibile e' `chunk`, prodotta
+// esclusivamente dopo `;`. END chiude l'azione ma non rende eseguibile il testo
+// che lo precede: un ultimo segmento senza `;` viene rifiutato.
+
+const G = require('./grammatica.js');
+
+const PENSIERO_INIZIO = '<|thought_start|>';
+const PENSIERO_FINE = '<|thought_end|>';
+const CODA_MINIMA = Math.max(PENSIERO_INIZIO.length, PENSIERO_FINE.length, 'ACTION'.length);
+
+function creaParser(options = {}) {
+  const bufferMassimo = Number.isInteger(options.bufferMassimo)
+    ? Math.max(256, options.bufferMassimo) : G.LIMITI.BUFFER_MASSIMO;
+  let buffer = '';
+  let stato = 'fuori';
+  let azione = null;
+  let sequenza = 0;
+
+  const scartoCorrente = () => azione ? {
+    observationId: azione.observationId,
+    chunkEmessi: azione.mouseVisto + azione.keysetEmessi,
+    ultimaSequenza: sequenza,
+  } : null;
+
+  function errore(motivo) {
+    const scarto = scartoCorrente();
+    azione = null;
+    stato = 'avvelenato';
+    return { tipo: 'errore', motivo, scarto };
+  }
+
+  function commitSegmento(grezzo) {
+    if (!azione) return errore('segmento fuori da ACTION');
+    const testo = grezzo.trim();
+    let parsed;
+    let indice;
+    if (!azione.mouseVisto) {
+      parsed = G.analizzaMouse(testo);
+      indice = 0;
+      if (!parsed.errore) azione.mouseVisto = 1;
+    } else {
+      if (azione.keysetEmessi >= G.LIMITI.CHUNK_PER_AZIONE) {
+        return errore(`piu' di ${G.LIMITI.CHUNK_PER_AZIONE} keyset in un'azione`);
+      }
+      parsed = G.analizzaKeyset(testo);
+      indice = azione.keysetEmessi;
+      if (!parsed.errore) azione.keysetEmessi += 1;
+    }
+    if (parsed.errore) return errore(parsed.errore);
+    sequenza += 1;
+    return {
+      tipo: 'chunk',
+      chunk: {
+        ...parsed,
+        observationId: azione.observationId,
+        ttlMs: azione.ttlMs,
+        sequenza,
+        indice,
+      },
+    };
+  }
+
+  function trovaAction() {
+    const match = /(?:^|\n)ACTION(?=\s)/.exec(buffer);
+    if (!match) return -1;
+    return match.index + (buffer[match.index] === '\n' ? 1 : 0);
+  }
+
+  function passo(finale) {
+    if (stato === 'pensiero') {
+      const fine = buffer.indexOf(PENSIERO_FINE);
+      if (fine < 0) {
+        const sicuro = finale ? buffer.length : Math.max(0, buffer.length - CODA_MINIMA);
+        if (!sicuro) return null;
+        const testo = buffer.slice(0, sicuro);
+        buffer = buffer.slice(sicuro);
+        return { evento: { tipo: 'pensiero', testo } };
+      }
+      const testo = buffer.slice(0, fine);
+      buffer = buffer.slice(fine + PENSIERO_FINE.length);
+      stato = 'fuori';
+      return { evento: testo ? { tipo: 'pensiero', testo } : { tipo: 'pensiero_fine' } };
+    }
+
+    if (stato !== 'corpo' && buffer.startsWith(PENSIERO_INIZIO)) {
+      buffer = buffer.slice(PENSIERO_INIZIO.length);
+      stato = 'pensiero';
+      return { avanzato: true };
+    }
+
+    if (stato === 'fuori' || stato === 'avvelenato') {
+      const idx = trovaAction();
+      if (idx < 0) {
+        const tieni = finale ? 0 : CODA_MINIMA;
+        if (buffer.length > tieni) {
+          buffer = tieni ? buffer.slice(-tieni) : '';
+          return { avanzato: true };
+        }
+        return null;
+      }
+      if (idx > 0) {
+        buffer = buffer.slice(idx);
+        return { avanzato: true };
+      }
+      const aCapo = buffer.indexOf('\n');
+      if (aCapo < 0) return null;
+      const testa = G.analizzaIntestazione(buffer.slice(0, aCapo).replace(/\r$/, ''));
+      buffer = buffer.slice(aCapo + 1);
+      if (testa.errore) return { evento: errore(testa.errore) };
+      azione = {
+        observationId: testa.observationId,
+        ttlMs: testa.ttlMs,
+        mouseVisto: 0,
+        keysetEmessi: 0,
+      };
+      stato = 'corpo';
+      return { evento: { tipo: 'intestazione', ...testa } };
+    }
+
+    const punto = buffer.indexOf(';');
+    const endMatch = /(?:^|\n)\s*END(?=\s|$)/.exec(buffer);
+    const fine = endMatch ? endMatch.index : -1;
+    if (punto >= 0 && (fine < 0 || punto < fine)) {
+      const segmento = buffer.slice(0, punto);
+      buffer = buffer.slice(punto + 1);
+      return { evento: commitSegmento(segmento) };
+    }
+    if (fine >= 0) {
+      const prefisso = buffer.slice(0, fine).trim();
+      const conclusa = azione;
+      buffer = buffer.slice(fine + endMatch[0].length);
+      if (prefisso) return { evento: errore('segmento prima di END privo di delimitatore ;') };
+      if (!conclusa.mouseVisto || conclusa.keysetEmessi !== G.LIMITI.CHUNK_PER_AZIONE) {
+        return { evento: errore(`azione incompleta: attesi mouse + ${G.LIMITI.CHUNK_PER_AZIONE} keyset`) };
+      }
+      azione = null;
+      stato = 'fuori';
+      return { evento: { tipo: 'fine_azione', observationId: conclusa.observationId, ultimaSequenza: sequenza } };
+    }
+    return null;
+  }
+
+  function estrai(finale) {
+    const eventi = [];
+    for (;;) {
+      const r = passo(finale);
+      if (!r) break;
+      if (r.evento) eventi.push(r.evento);
+    }
+    return eventi;
+  }
+
+  return {
+    push(delta) {
+      buffer += String(delta == null ? '' : delta);
+      if (buffer.length > bufferMassimo) {
+        const event = errore(`buffer oltre ${bufferMassimo} byte`);
+        buffer = buffer.slice(-CODA_MINIMA);
+        return [event, ...estrai(false)];
+      }
+      return estrai(false);
+    },
+    fine() {
+      const eventi = estrai(true);
+      if (stato === 'corpo' && azione) eventi.push({ tipo: 'troncata', ...scartoCorrente() });
+      azione = null;
+      stato = 'fuori';
+      buffer = '';
+      return eventi;
+    },
+    reset() {
+      const scarto = scartoCorrente();
+      buffer = '';
+      stato = 'fuori';
+      azione = null;
+      return scarto;
+    },
+    stato: () => stato,
+    diagnostica: () => ({ stato, bytesInBuffer: buffer.length, sequenza }),
+  };
+}
+
+module.exports = { creaParser, PENSIERO_INIZIO, PENSIERO_FINE };

package/dist/vendor/computer-use/rac/protocol.js

@@ -0,0 +1,136 @@
+'use strict';
+
+const crypto = require('node:crypto');
+
+const EXTENSION_ID = 'io.vascend.mcp.reactive-control/0.1';
+const MAGIC = Buffer.from('RAC1');
+const VERSION = 1;
+const HEADER_BYTES = 52;
+
+const MESSAGE_TYPES = Object.freeze({
+  OBS_KEYFRAME: 1,
+  OBS_DELTA: 2,
+  ACTION_START: 3,
+  ACTION_CHUNK: 4,
+  ACTION_REVOKE: 5,
+  ACK: 6,
+  SAFETY_STOP: 7,
+});
+const MESSAGE_NAMES = Object.freeze(Object.fromEntries(
+  Object.entries(MESSAGE_TYPES).map(([name, value]) => [value, name]),
+));
+
+const SERVER_CAPABILITIES = Object.freeze({
+  extension: EXTENSION_ID,
+  version: VERSION,
+  transport: ['node-ipc'],
+  framing: ['rac-binary-v1'],
+  observation: ['keyframe', 'delta', 'checkpoint', 'revoke'],
+  actionRateHz: 30,
+  observationRateHz: 5,
+  maxActionHorizonMs: 200,
+  maxLeaseMs: 250,
+  strictObservationMaxAgeMs: 450,
+  cumulativeAck: true,
+  checksum: 'crc32',
+  duplexObservations: false,
+});
+
+let crcTable = null;
+function tableCrc32() {
+  if (crcTable) return crcTable;
+  crcTable = Array.from({ length: 256 }, (_, index) => {
+    let value = index;
+    for (let bit = 0; bit < 8; bit += 1) {
+      value = (value >>> 1) ^ ((value & 1) ? 0xedb88320 : 0);
+    }
+    return value >>> 0;
+  });
+  return crcTable;
+}
+
+function crc32(value) {
+  const bytes = Buffer.isBuffer(value) ? value : Buffer.from(value || '');
+  const table = tableCrc32();
+  let crc = 0xffffffff;
+  for (const byte of bytes) crc = (crc >>> 8) ^ table[(crc ^ byte) & 0xff];
+  return (crc ^ 0xffffffff) >>> 0;
+}
+
+function sessionDigest(sessionId) {
+  return crypto.createHash('sha256').update(String(sessionId || '')).digest().subarray(0, 16);
+}
+
+function safeBigInt(value, name) {
+  try {
+    const parsed = BigInt(value || 0);
+    if (parsed < 0n || parsed > 0xffffffffffffffffn) throw new RangeError(name);
+    return parsed;
+  } catch (_) {
+    throw new TypeError(`${name || 'value'} non valido`);
+  }
+}
+
+function encodeFrame(input = {}) {
+  const type = typeof input.type === 'string' ? MESSAGE_TYPES[input.type] : Number(input.type);
+  if (!MESSAGE_NAMES[type]) throw new TypeError('RAC_MESSAGE_TYPE_INVALID');
+  const payload = Buffer.isBuffer(input.payload) ? input.payload : Buffer.from(String(input.payload || ''), 'utf8');
+  if (payload.length > 16 * 1024 * 1024) throw new RangeError('RAC_PAYLOAD_TOO_LARGE');
+  const header = Buffer.alloc(HEADER_BYTES);
+  MAGIC.copy(header, 0);
+  header.writeUInt8(VERSION, 4);
+  header.writeUInt8(type, 5);
+  header.writeUInt16BE(Number(input.flags || 0) & 0xffff, 6);
+  header.writeUInt32BE(Number(input.sequence || 0) >>> 0, 8);
+  header.writeBigUInt64BE(safeBigInt(input.monotonicUs, 'monotonicUs'), 12);
+  header.writeBigUInt64BE(safeBigInt(input.observationId, 'observationId'), 20);
+  header.writeUInt32BE(payload.length >>> 0, 28);
+  header.writeUInt32BE(crc32(payload), 32);
+  sessionDigest(input.sessionId).copy(header, 36);
+  return Buffer.concat([header, payload]);
+}
+
+function decodeFrame(value, expected = {}) {
+  const frame = Buffer.isBuffer(value) ? value : Buffer.from(value || '');
+  if (frame.length < HEADER_BYTES) return { ok: false, code: 'RAC_FRAME_TRUNCATED' };
+  if (!frame.subarray(0, 4).equals(MAGIC)) return { ok: false, code: 'RAC_FRAME_MAGIC' };
+  if (frame.readUInt8(4) !== VERSION) return { ok: false, code: 'RAC_FRAME_VERSION' };
+  const type = frame.readUInt8(5);
+  if (!MESSAGE_NAMES[type]) return { ok: false, code: 'RAC_FRAME_TYPE' };
+  const payloadLength = frame.readUInt32BE(28);
+  if (frame.length !== HEADER_BYTES + payloadLength) return { ok: false, code: 'RAC_FRAME_LENGTH' };
+  const payload = frame.subarray(HEADER_BYTES);
+  if (crc32(payload) !== frame.readUInt32BE(32)) return { ok: false, code: 'RAC_FRAME_CHECKSUM' };
+  if (expected.sessionId && !frame.subarray(36, 52).equals(sessionDigest(expected.sessionId))) {
+    return { ok: false, code: 'RAC_FRAME_SESSION' };
+  }
+  const observationId = frame.readBigUInt64BE(20).toString();
+  if (expected.observationId && String(expected.observationId) !== observationId) {
+    return { ok: false, code: 'STALE_OBSERVATION' };
+  }
+  return {
+    ok: true,
+    type: MESSAGE_NAMES[type],
+    typeId: type,
+    flags: frame.readUInt16BE(6),
+    sequence: frame.readUInt32BE(8),
+    monotonicUs: frame.readBigUInt64BE(12),
+    observationId,
+    payload,
+    checksum: frame.readUInt32BE(32),
+  };
+}
+
+function negotiateCapabilities(client = {}) {
+  const extension = String(client.extension || EXTENSION_ID);
+  if (extension !== EXTENSION_ID) return { ok: false, code: 'RAC_EXTENSION_UNSUPPORTED' };
+  const requestedTransports = Array.isArray(client.transport) ? client.transport : ['node-ipc'];
+  const transport = SERVER_CAPABILITIES.transport.find((item) => requestedTransports.includes(item));
+  if (!transport) return { ok: false, code: 'RAC_TRANSPORT_UNSUPPORTED' };
+  return { ok: true, ...SERVER_CAPABILITIES, transport };
+}
+
+module.exports = {
+  EXTENSION_ID, VERSION, HEADER_BYTES, MESSAGE_TYPES, SERVER_CAPABILITIES,
+  crc32, encodeFrame, decodeFrame, negotiateCapabilities,
+};

package/install.ps1

@@ -0,0 +1,30 @@
+# Public entry point: https://cdn.jsdelivr.net/npm/@vascend/talos@latest/install.ps1
+& {
+    $ErrorActionPreference = 'Stop'
+    $node = Get-Command node.exe -ErrorAction SilentlyContinue
+    $npm = Get-Command npm.cmd -ErrorAction SilentlyContinue
+    if (-not $node -or -not $npm) {
+        throw 'Talos requires Node.js 20 or newer (including npm). Install it from https://nodejs.org and run this command again.'
+    }
+    & $node.Source -e 'process.exit(Number(process.versions.node.split(String.fromCharCode(46))[0]) >= 20 ? 0 : 1)'
+    if ($LASTEXITCODE -ne 0) { throw 'Please update Node.js to version 20 or newer.' }
+    $talosVersion = if ($env:TALOS_VERSION) { $env:TALOS_VERSION } else { 'latest' }
+    if ($talosVersion -notmatch '\A(?:latest|[0-9]+\.[0-9]+\.[0-9]+)\z') {
+        throw 'TALOS_VERSION must be latest or a stable version such as 0.1.0.'
+    }
+    $talosPrefix = if ($env:TALOS_INSTALL_DIR) { $env:TALOS_INSTALL_DIR } else { Join-Path $env:LOCALAPPDATA 'Programs\Talos' }
+    Write-Host "Installing Talos $talosVersion in $talosPrefix"
+    & $npm.Source install --global --prefix $talosPrefix --registry=https://registry.npmjs.org "@vascend/talos@$talosVersion"
+    if ($LASTEXITCODE -ne 0) { throw 'Talos installation failed. Check the npm output above.' }
+    $talosEntry = Join-Path $talosPrefix 'node_modules\@vascend\talos\dist\index.js'
+    & $node.Source $talosEntry --version
+    if ($LASTEXITCODE -ne 0) { throw 'Talos was installed but the startup check failed.' }
+    if ($env:TALOS_NO_MODIFY_PATH -ne '1') {
+        $talosUserPath = [Environment]::GetEnvironmentVariable('Path', 'User')
+        if (($talosUserPath -split ';') -notcontains $talosPrefix) {
+            [Environment]::SetEnvironmentVariable('Path', (([string]$talosUserPath).TrimEnd(';') + ';' + $talosPrefix).TrimStart(';'), 'User')
+        }
+    }
+    if (($env:Path -split ';') -notcontains $talosPrefix) { $env:Path = "$talosPrefix;$env:Path" }
+    Write-Host 'Talos is ready. Run talos to sign in.'
+}

package/install.sh

@@ -0,0 +1,50 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Public entry point: https://cdn.jsdelivr.net/npm/@vascend/talos@latest/install.sh
+main() {
+  if ! command -v node >/dev/null 2>&1 || ! command -v npm >/dev/null 2>&1; then
+    printf '%s\n' 'Talos requires Node.js 20 or newer (including npm). Install it from https://nodejs.org and run this command again.' >&2
+    return 1
+  fi
+  if ! node -e 'process.exit(Number(process.versions.node.split(".")[0]) >= 20 ? 0 : 1)'; then
+    printf '%s\n' 'Please update Node.js to version 20 or newer before installing Talos.' >&2
+    return 1
+  fi
+  local version="${TALOS_VERSION:-latest}"
+  if [[ "$version" != latest && ! "$version" =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
+    printf '%s\n' 'TALOS_VERSION must be latest or a stable version such as 0.1.0.' >&2
+    return 1
+  fi
+  local install_dir="${TALOS_INSTALL_DIR:-$HOME/.local}"
+  local bin_dir="$install_dir/bin"
+  printf 'Installing Talos %s in %s\n' "$version" "$install_dir"
+  npm install --global --prefix "$install_dir" --registry=https://registry.npmjs.org "@vascend/talos@$version"
+  "$bin_dir/talos" --version
+  case ":$PATH:" in
+    *":$bin_dir:"*) ;;
+    *)
+      local profile=""
+      case "${SHELL:-}" in
+        */zsh) profile="$HOME/.zshrc" ;;
+        */bash)
+          if [[ "$(uname -s)" == Darwin ]]; then profile="$HOME/.bash_profile"; else profile="$HOME/.bashrc"; fi
+          ;;
+      esac
+      if [[ -n "$profile" && "${TALOS_NO_MODIFY_PATH:-0}" != 1 ]]; then
+        local path_line
+        printf -v path_line 'export PATH=%q:"$PATH"' "$bin_dir"
+        if ! grep -Fqx "$path_line" "$profile" 2>/dev/null; then
+          printf '\n# Vascend Talos\n%s\n' "$path_line" >> "$profile"
+        fi
+        printf 'Open a new terminal, then run: talos\n'
+      else
+        printf 'Add %s to your PATH, then run: talos\n' "$bin_dir"
+      fi
+      printf 'To start immediately: %q\n' "$bin_dir/talos"
+      ;;
+  esac
+  printf '%s\n' 'Talos is ready. Run talos to sign in.'
+}
+
+main "$@"

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@vascend/talos",
+  "version": "0.1.0",
+  "description": "Vascend Talos - extensible coding agent for your terminal",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/VascendTechnologies/vascend-talos.git"
+  },
+  "homepage": "https://vascend.it/talos",
+  "type": "module",
+  "bin": {
+    "horizon": "./dist/index.js",
+    "talos": "./dist/index.js"
+  },
+  "exports": {
+    ".": "./dist/sdk.js"
+  },
+  "files": [
+    "dist",
+    "install.sh",
+    "install.ps1"
+  ],
+  "scripts": {
+    "dev": "bun run src/index.ts",
+    "start": "bun run src/index.ts",
+    "install:cli": "bun run build && bun link",
+    "backend": "bun run src/backend/index.ts",
+    "backend:dev": "bun --watch run src/backend/index.ts",
+    "build": "tsc -p tsconfig.json && node scripts/copy-computer-use.mjs",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "node scripts/run-unit-tests.mjs",
+    "test:unit": "node scripts/run-unit-tests.mjs",
+    "test:e2e": "E2E=1 bun test ./test/e2e",
+    "test:e2e:dry": "bun test ./test/e2e",
+    "bench": "bun run bench/index.ts",
+    "bench:context": "bun run bench/context-gap/index.ts",
+    "bench:retrieval": "bun run bench/hybrid-retrieval/index.ts",
+    "typecheck:bench": "tsc -p tsconfig.bench.json",
+    "prepack": "npm run build",
+    "bench:rollup": "bun run bench/rollup-quality/index.ts"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.1.0",
+    "@types/node": "^22.10.0",
+    "@xterm/headless": "^6.0.0",
+    "typescript": "^5.7.0"
+  },
+  "license": "UNLICENSED",
+  "private": false,
+  "publishConfig": {
+    "access": "public"
+  }
+}