talos-code 0.0.1 → 0.2.0

package/vendor/context-engine/src/node/legacy-import.mjs

@@ -0,0 +1,92 @@
+import { createHash } from 'node:crypto';
+import { ContextStoreError } from './sqlite-store.mjs';
+import { verifyContextArchive } from './context-export.mjs';
+
+const hash = value => createHash('sha256').update(value).digest('hex');
+const object = value => value !== null && typeof value === 'object' && !Array.isArray(value);
+const id = value => typeof value === 'string' && value.length > 0 && value.length <= 256;
+
+function validJson(value, ancestors = new Set()) {
+  if (value === null || ['string', 'boolean'].includes(typeof value) || (typeof value === 'number' && Number.isFinite(value))) return true;
+  if ((!object(value) && !Array.isArray(value)) || ancestors.has(value) || (object(value) && Object.getPrototypeOf(value) !== Object.prototype)) return false;
+  if (Array.isArray(value) && Object.keys(value).length !== value.length) return false;
+  ancestors.add(value);
+  const valid = Object.values(value).every(child => validJson(child, ancestors));
+  ancestors.delete(value);
+  return valid;
+}
+
+function validMessages(messages) {
+  if (!Array.isArray(messages) || !messages.length || !validJson(messages)) return false;
+  const pending = new Set();
+  for (const message of messages) {
+    if (!object(message) || !['system', 'developer', 'user', 'assistant', 'tool'].includes(message.role) || (!Object.hasOwn(message, 'content') && !(message.role === 'assistant' && Array.isArray(message.tool_calls) && message.tool_calls.length))) return false;
+    if (message.tool_calls !== undefined) {
+      if (message.role !== 'assistant' || !Array.isArray(message.tool_calls)) return false;
+      for (const call of message.tool_calls) {
+        if (!object(call) || !id(call.id) || pending.has(call.id) || call.type !== 'function' || !object(call.function) || !id(call.function.name) || typeof call.function.arguments !== 'string') return false;
+        pending.add(call.id);
+      }
+    }
+    if (message.role === 'tool' && (!id(message.tool_call_id) || !pending.delete(message.tool_call_id))) return false;
+  }
+  try { JSON.stringify(messages); } catch { return false; }
+  return true;
+}
+
+/** First validate the body, then compare generations. A malformed late final
+ * must never hide a usable checkpoint from an earlier run. */
+export function selectLastValidCheckpoint(records) {
+  if (!Array.isArray(records)) throw new ContextStoreError('Legacy records must be an array', 'CTX_LEGACY_CORRUPT');
+  let selected = null;
+  for (let recordIndex = 0; recordIndex < records.length; recordIndex++) {
+    const record = records[recordIndex];
+    const messages = record?.tipo === 'messaggi-finali' ? record.messaggiFinali : record?.tipo === 'checkpoint-ripresa' ? record.messaggi : null;
+    const versioneGiro = record?.versioneGiro ?? 0;
+    if (!Number.isSafeInteger(versioneGiro) || versioneGiro < 0 || !validMessages(messages)) continue;
+    if (!selected || versioneGiro >= selected.versioneGiro) selected = { messages: JSON.parse(JSON.stringify(messages)), versioneGiro, recordIndex };
+  }
+  return selected;
+}
+
+/** Import once through the same atomic archive boundary as normal exports.
+ * jsonl is captured bytes/text, never a path; no legacy source is rewritten. */
+export async function importLegacySession({ sessionId, jsonl, settings, metadata = {} }, { store }) {
+  if (typeof jsonl !== 'string' && !(jsonl instanceof Uint8Array)) throw new ContextStoreError('Legacy JSONL must be captured text or bytes', 'CTX_LEGACY_CORRUPT');
+  const bytes = typeof jsonl === 'string' ? Buffer.from(jsonl, 'utf8') : Buffer.from(jsonl);
+  let text;
+  try { text = new TextDecoder('utf-8', { fatal: true }).decode(bytes); }
+  catch (cause) { throw new ContextStoreError('Legacy JSONL is not valid UTF-8', 'CTX_LEGACY_CORRUPT', { cause }); }
+  const lines = text.split('\n').filter(line => line.trim() !== '');
+  const records = [];
+  let corruptTail = false;
+  for (let index = 0; index < lines.length; index++) {
+    try {
+      const parsed = JSON.parse(lines[index]);
+      if (!object(parsed)) throw new Error('Expected a legacy record object');
+      records.push(parsed);
+    } catch (cause) {
+      if (index === lines.length - 1) { corruptTail = true; break; }
+      throw new ContextStoreError(`Legacy JSONL has a corrupt intermediate record at line ${index + 1}`, 'CTX_LEGACY_CORRUPT', { cause });
+    }
+  }
+  const checkpoint = selectLastValidCheckpoint(records);
+  if (!checkpoint) throw new ContextStoreError('Legacy JSONL contains no valid message checkpoint', 'CTX_LEGACY_NO_CHECKPOINT');
+  const sourceSha256 = hash(bytes);
+  const sourceBlobId = `legacy-jsonl:${sourceSha256}`;
+  const headerDate = records.find(record => typeof record.avviataAlle === 'string')?.avviataAlle;
+  const createdAt = typeof headerDate === 'string' && /^\d{4}-\d\d-\d\dT\d\d:\d\d(?::\d\d(?:\.\d+)?)?(?:Z|[+-]\d\d:\d\d)$/.test(headerDate) && Number.isFinite(Date.parse(headerDate)) ? headerDate : '1970-01-01T00:00:00.000Z';
+  const originals = checkpoint.messages.map((message, index) => ({
+    id: `legacy:${sourceSha256}:${index + 1}`, message, createdAt,
+    origin: 'legacy-jsonl',
+    schema: 'talos.context.record.v1', sessionId, sequence: index + 1, sha256: hash(JSON.stringify(message)),
+  }));
+  const session = {
+    schema: 'talos.context.snapshot.v1', sessionId, revision: originals.length ? 1 : 0, stateRevision: 0, headSequence: originals.length, settings,
+    metadata: { ...metadata, legacy: { sourceBlobId, sourceSha256, corruptTail, versioneGiro: checkpoint.versioneGiro, recordIndex: checkpoint.recordIndex, records: originals.map((record, messageIndex) => ({ recordId: record.id, messageIndex })) } },
+    activeVersion: null, facts: [], jobs: [],
+  };
+  const payload = { schema: 'talos.context.archive.v1', session, records: originals, versions: [], facts: [], jobs: [], usage: [], blobs: [{ id: sourceBlobId, sha256: sourceSha256, mimeType: 'application/x-ndjson', base64: bytes.toString('base64') }] };
+  const archive = { ...payload, manifest: { schema: 'talos.context.manifest.v1', algorithm: 'sha256', payloadSha256: hash(JSON.stringify(payload)) } };
+  return store.importSession({ archive: verifyContextArchive(archive) });
+}

package/vendor/context-engine/src/node/migrations/001-context.sql

@@ -0,0 +1,126 @@
+CREATE TABLE IF NOT EXISTS context_sessions (
+  session_id TEXT PRIMARY KEY,
+  revision INTEGER NOT NULL DEFAULT 0 CHECK(revision >= 0),
+  state_revision INTEGER NOT NULL DEFAULT 0 CHECK(state_revision >= 0),
+  head_sequence INTEGER NOT NULL DEFAULT 0 CHECK(head_sequence >= 0),
+  settings_json TEXT NOT NULL CHECK(json_valid(settings_json)),
+  metadata_json TEXT NOT NULL CHECK(json_valid(metadata_json)),
+  active_version_id TEXT
+) STRICT;
+CREATE TABLE IF NOT EXISTS original_records (
+  session_id TEXT NOT NULL REFERENCES context_sessions(session_id),
+  id TEXT NOT NULL,
+  sequence INTEGER NOT NULL CHECK(sequence > 0),
+  sha256 TEXT NOT NULL,
+  record_json TEXT NOT NULL CHECK(json_valid(record_json)),
+  PRIMARY KEY(session_id, id),
+  UNIQUE(session_id, sequence)
+) STRICT;
+CREATE TRIGGER IF NOT EXISTS originals_no_update BEFORE UPDATE ON original_records
+BEGIN SELECT RAISE(ABORT, 'original records are immutable'); END;
+CREATE TRIGGER IF NOT EXISTS originals_no_delete BEFORE DELETE ON original_records
+BEGIN SELECT RAISE(ABORT, 'original records are immutable'); END;
+CREATE TABLE IF NOT EXISTS content_blobs (
+  sha256 TEXT PRIMARY KEY,
+  bytes BLOB NOT NULL
+) STRICT;
+CREATE TRIGGER IF NOT EXISTS blobs_no_update BEFORE UPDATE ON content_blobs
+BEGIN SELECT RAISE(ABORT, 'original blobs are immutable'); END;
+CREATE TRIGGER IF NOT EXISTS blobs_no_delete BEFORE DELETE ON content_blobs
+BEGIN SELECT RAISE(ABORT, 'original blobs are immutable'); END;
+CREATE TABLE IF NOT EXISTS record_assets (
+  session_id TEXT NOT NULL REFERENCES context_sessions(session_id),
+  id TEXT NOT NULL,
+  sha256 TEXT NOT NULL REFERENCES content_blobs(sha256),
+  mime_type TEXT NOT NULL,
+  PRIMARY KEY(session_id, id)
+) STRICT;
+CREATE TRIGGER IF NOT EXISTS assets_no_update BEFORE UPDATE ON record_assets
+BEGIN SELECT RAISE(ABORT, 'original assets are immutable'); END;
+CREATE TABLE IF NOT EXISTS context_versions (
+  ordinal INTEGER PRIMARY KEY,
+  session_id TEXT NOT NULL REFERENCES context_sessions(session_id),
+  id TEXT NOT NULL,
+  version_json TEXT NOT NULL CHECK(json_valid(version_json)),
+  UNIQUE(session_id, id)
+) STRICT;
+CREATE TRIGGER IF NOT EXISTS versions_no_update BEFORE UPDATE ON context_versions
+BEGIN SELECT RAISE(ABORT, 'context versions are immutable'); END;
+CREATE TRIGGER IF NOT EXISTS versions_no_delete BEFORE DELETE ON context_versions
+BEGIN SELECT RAISE(ABORT, 'context versions are immutable'); END;
+CREATE TABLE IF NOT EXISTS summary_nodes (
+  session_id TEXT NOT NULL,
+  version_id TEXT NOT NULL,
+  summary_json TEXT NOT NULL CHECK(json_valid(summary_json)),
+  PRIMARY KEY(session_id, version_id),
+  FOREIGN KEY(session_id, version_id) REFERENCES context_versions(session_id, id)
+) STRICT;
+CREATE TABLE IF NOT EXISTS protected_facts (
+  session_id TEXT NOT NULL REFERENCES context_sessions(session_id),
+  id TEXT NOT NULL,
+  fact_json TEXT NOT NULL CHECK(json_valid(fact_json)),
+  PRIMARY KEY(session_id, id)
+) STRICT;
+CREATE TABLE IF NOT EXISTS compaction_jobs (
+  session_id TEXT NOT NULL REFERENCES context_sessions(session_id),
+  id TEXT NOT NULL,
+  idempotency_key TEXT NOT NULL,
+  state TEXT NOT NULL,
+  job_json TEXT NOT NULL CHECK(json_valid(job_json)),
+  PRIMARY KEY(session_id, id),
+  UNIQUE(session_id, idempotency_key)
+) STRICT;
+CREATE UNIQUE INDEX IF NOT EXISTS context_one_active_job ON compaction_jobs(session_id)
+WHERE state IN ('queued','preparing','summarizing','validating','ready');
+CREATE TABLE IF NOT EXISTS context_outbox (
+  ordinal INTEGER PRIMARY KEY,
+  session_id TEXT NOT NULL REFERENCES context_sessions(session_id),
+  id TEXT NOT NULL,
+  event_json TEXT NOT NULL CHECK(json_valid(event_json)),
+  acknowledged INTEGER NOT NULL DEFAULT 0 CHECK(acknowledged IN (0,1)),
+  UNIQUE(session_id, id)
+) STRICT;
+CREATE TABLE IF NOT EXISTS search_chunks (
+  rowid INTEGER PRIMARY KEY,
+  session_id TEXT NOT NULL,
+  id TEXT NOT NULL,
+  record_id TEXT NOT NULL,
+  sequence INTEGER NOT NULL,
+  text TEXT NOT NULL,
+  start INTEGER NOT NULL,
+  end INTEGER NOT NULL,
+  embedding BLOB,
+  dimensions INTEGER,
+  UNIQUE(session_id, id),
+  FOREIGN KEY(session_id, record_id) REFERENCES original_records(session_id, id)
+) STRICT;
+CREATE VIRTUAL TABLE IF NOT EXISTS search_chunks_fts USING fts5(text, content='search_chunks', content_rowid='rowid');
+CREATE TRIGGER IF NOT EXISTS search_chunks_insert AFTER INSERT ON search_chunks
+BEGIN INSERT INTO search_chunks_fts(rowid,text) VALUES(new.rowid,new.text); END;
+CREATE TRIGGER IF NOT EXISTS search_chunks_delete AFTER DELETE ON search_chunks
+BEGIN INSERT INTO search_chunks_fts(search_chunks_fts,rowid,text) VALUES('delete',old.rowid,old.text); END;
+CREATE TABLE IF NOT EXISTS usage_records (
+  ordinal INTEGER PRIMARY KEY,
+  session_id TEXT NOT NULL REFERENCES context_sessions(session_id),
+  operation_id TEXT NOT NULL,
+  job_id TEXT,
+  usage_json TEXT NOT NULL CHECK(json_valid(usage_json)),
+  UNIQUE(session_id, operation_id)
+) STRICT;
+CREATE TABLE IF NOT EXISTS context_mutations (
+  session_id TEXT NOT NULL REFERENCES context_sessions(session_id),
+  idempotency_key TEXT NOT NULL,
+  request_fingerprint TEXT NOT NULL,
+  result_json TEXT NOT NULL CHECK(json_valid(result_json)),
+  PRIMARY KEY(session_id,idempotency_key)
+) STRICT;
+PRAGMA user_version = 1;
+
+-- 09/09/2026 — l'ULTIMA misura preparata per la richiesta (strumenti e riserva compresi), con la
+-- revisione a cui si riferisce: la modale la mostra come «misurata alle …», mai come dato vivo.
+CREATE TABLE IF NOT EXISTS context_measurements (
+  session_id TEXT PRIMARY KEY REFERENCES context_sessions(session_id),
+  revision INTEGER NOT NULL CHECK(revision >= 0),
+  measured_at TEXT NOT NULL,
+  measurement_json TEXT NOT NULL CHECK(json_valid(measurement_json))
+) STRICT;

package/vendor/context-engine/src/node/sqlite-store.mjs

@@ -0,0 +1,85 @@
+import { Worker } from 'node:worker_threads';
+
+export class ContextStoreError extends Error {
+  constructor(message, code = 'CTX_STORE_FAILED', options) {
+    super(message, options);
+    this.name = 'ContextStoreError';
+    this.code = code;
+  }
+}
+
+/** SQLite owns all durable state in one dedicated worker. Requests are copied
+ * when submitted and serialized in the worker, including backup and shutdown. */
+export function createSqliteContextStore({ databasePath, vectorExtension = false, faultPoint } = {}) {
+  if (typeof databasePath !== 'string' || !databasePath || databasePath.includes('\0')) {
+    throw new ContextStoreError('A database path is required', 'CTX_INVALID_INPUT');
+  }
+  const worker = new Worker(new URL('./sqlite-worker.mjs', import.meta.url), {
+    workerData: { databasePath, vectorExtension, faultPoint },
+  });
+  const pending = new Map();
+  let nextId = 0;
+  let failure;
+  let closing = false;
+  let closePromise;
+  let resolveExit;
+  const exited = new Promise(resolve => { resolveExit = resolve; });
+  const fail = error => {
+    failure ??= error;
+    for (const entry of pending.values()) entry.reject(failure);
+    pending.clear();
+  };
+  worker.on('message', response => {
+    const entry = pending.get(response?.id);
+    if (!entry) return;
+    pending.delete(response.id);
+    if (response.error) entry.reject(new ContextStoreError(response.error.message, response.error.code));
+    else entry.resolve(response.result);
+  });
+  worker.on('error', error => fail(new ContextStoreError(error.message, 'CTX_WORKER_FAILED')));
+  worker.on('exit', code => {
+    if (!closing || code !== 0 || pending.size) fail(new ContextStoreError(`Context worker exited (${code})`, 'CTX_WORKER_EXIT'));
+    resolveExit();
+  });
+  const request = (method, args = {}) => {
+    if (failure) return Promise.reject(failure);
+    if (closing && method !== 'close') return Promise.reject(new ContextStoreError('Context store is closed', 'CTX_STORE_CLOSED'));
+    const id = ++nextId;
+    return new Promise((resolve, reject) => {
+      pending.set(id, { resolve, reject });
+      try { worker.postMessage({ id, method, args }); }
+      catch (error) {
+        pending.delete(id);
+        reject(new ContextStoreError('Context arguments must be cloneable data', 'CTX_INVALID_INPUT', { cause: error }));
+      }
+    });
+  };
+  const store = {};
+  for (const method of [
+    'initSession', 'readContextSnapshot', 'recordMeasurement', 'appendOriginalBatch', 'readOriginals',
+    'updateSessionSettings', 'listContextVersions', 'commitContextVersion',
+    'restoreContextVersion', 'claimContextJob', 'saveJobProgress', 'readContextJob',
+    'upsertProtectedFact', 'removeProtectedFact', 'readContextOutbox', 'ackContextEvent', 'recordContextNotice',
+    'recordUsage', 'readUsage', 'readContextMutation', 'putBlob', 'readBlob', 'replaceSearchChunks',
+    'searchLexical', 'searchVector', 'exportSession', 'importSession', 'backup', 'health',
+  ]) store[method] = args => request(method, args);
+  store.close = () => {
+    if (closePromise) return closePromise;
+    closing = true;
+    closePromise = (async () => {
+      if (!failure) await request('close');
+      await exited;
+    })();
+    return closePromise;
+  };
+  return Object.freeze(store);
+}
+
+export const appendOriginalBatch = (options, { store }) => store.appendOriginalBatch(options);
+export const commitContextVersion = (options, { store }) => store.commitContextVersion(options);
+export const readContextSnapshot = (options, { store }) => store.readContextSnapshot(options);
+export const recordMeasurement = (options, { store }) => store.recordMeasurement(options);
+export const saveJobProgress = (options, { store }) => store.saveJobProgress(options);
+export const claimContextJob = (options, { store }) => store.claimContextJob(options);
+export const readContextOutbox = (options, { store }) => store.readContextOutbox(options);
+export const ackContextEvent = (options, { store }) => store.ackContextEvent(options);