atris 3.14.0 → 3.15.11

package/lib/company-brain-sync.js

@@ -0,0 +1,178 @@
+const fs = require('fs');
+const path = require('path');
+
+function scopedSyncPath(rootDir, prefix, cloudPath) {
+  const rel = String(cloudPath || '').replace(/^\/+/, '');
+  const target = path.resolve(rootDir, prefix, rel);
+  const base = path.resolve(rootDir, prefix);
+  if (!target.startsWith(`${base}${path.sep}`) && target !== base) {
+    throw new Error(`Refusing to write outside ${prefix}: ${cloudPath}`);
+  }
+  return target;
+}
+
+function classifyPath({ path, base, local, remote }) {
+  const inBase = Boolean(base);
+  const inLocal = Boolean(local);
+  const inRemote = Boolean(remote);
+  const baseHash = base && base.hash;
+  const localHash = local && local.hash;
+  const remoteHash = remote && remote.hash;
+
+  if (inLocal && inRemote && inBase) {
+    const localChanged = localHash !== baseHash;
+    const remoteChanged = remoteHash !== baseHash;
+    if (!localChanged && !remoteChanged) return { path, status: 'unchanged', action: 'none' };
+    if (localChanged && !remoteChanged) return { path, status: 'local_updated', action: 'push' };
+    if (!localChanged && remoteChanged) return { path, status: 'remote_updated', action: 'pull' };
+    if (localHash === remoteHash) return { path, status: 'converged', action: 'record' };
+    return { path, status: 'conflict_updated', action: 'review' };
+  }
+
+  if (!inBase && inLocal && !inRemote) return { path, status: 'local_created', action: 'push' };
+  if (!inBase && !inLocal && inRemote) return { path, status: 'remote_created', action: 'pull' };
+  if (!inBase && inLocal && inRemote) {
+    if (localHash === remoteHash) return { path, status: 'converged', action: 'record' };
+    return { path, status: 'conflict_created', action: 'review' };
+  }
+
+  if (inBase && !inLocal && inRemote) {
+    if (remoteHash === baseHash) return { path, status: 'local_deleted', action: 'hold_delete' };
+    return { path, status: 'conflict_local_deleted_remote_updated', action: 'review' };
+  }
+
+  if (inBase && inLocal && !inRemote) {
+    if (localHash === baseHash) return { path, status: 'remote_deleted', action: 'pull_delete' };
+    return { path, status: 'conflict_remote_deleted_local_updated', action: 'review' };
+  }
+
+  if (inBase && !inLocal && !inRemote) return { path, status: 'deleted_both', action: 'record' };
+
+  return { path, status: 'unknown', action: 'review' };
+}
+
+function classifyBrainSync({ baseFiles = {}, localFiles = {}, remoteFiles = {}, scopePrefixes = ['/atris/'] } = {}) {
+  const inScope = (p) => !scopePrefixes || scopePrefixes.length === 0 || scopePrefixes.some((prefix) => p.startsWith(prefix));
+  const paths = new Set([
+    ...Object.keys(baseFiles),
+    ...Object.keys(localFiles),
+    ...Object.keys(remoteFiles),
+  ].filter(inScope));
+
+  const changes = [...paths].sort().map((p) => classifyPath({
+    path: p,
+    base: baseFiles[p],
+    local: localFiles[p],
+    remote: remoteFiles[p],
+  }));
+
+  const summary = {
+    push: changes.filter((c) => c.action === 'push').length,
+    pull: changes.filter((c) => c.action === 'pull' || c.action === 'pull_delete').length,
+    review: changes.filter((c) => c.action === 'review').length,
+    holdDelete: changes.filter((c) => c.action === 'hold_delete').length,
+    unchanged: changes.filter((c) => c.action === 'none' || c.action === 'record').length,
+  };
+
+  return { changes, summary };
+}
+
+function renderSyncSummary(plan) {
+  const lines = [];
+  lines.push('Company brain sync');
+  lines.push(`  push: ${plan.summary.push}`);
+  lines.push(`  pull: ${plan.summary.pull}`);
+  lines.push(`  review: ${plan.summary.review}`);
+  lines.push(`  held deletes: ${plan.summary.holdDelete}`);
+  if (plan.summary.review > 0) {
+    lines.push('');
+    lines.push('Needs review:');
+    for (const change of plan.changes.filter((c) => c.action === 'review')) {
+      lines.push(`  - ${change.path.replace(/^\//, '')} (${change.status})`);
+    }
+  }
+  return `${lines.join('\n')}\n`;
+}
+
+function buildConflictReviewPacket({ plan, baseContents = {}, localContents = {}, remoteContents = {}, timestamp = 'sync-review' } = {}) {
+  const conflicts = (plan && plan.changes ? plan.changes : []).filter((change) => change.action === 'review');
+  const files = {};
+  const summary = [];
+
+  summary.push('# Company Brain Sync Review');
+  summary.push('');
+  summary.push(`Created: ${timestamp}`);
+  summary.push('');
+  summary.push(`${conflicts.length} file${conflicts.length === 1 ? '' : 's'} need review before publishing.`);
+  summary.push('');
+
+  for (const change of conflicts) {
+    const rel = change.path.replace(/^\/+/, '');
+    const packetBase = `.atris/sync/conflicts/${timestamp}/${rel}`;
+    const basePath = `${packetBase}.base`;
+    const localPath = `${packetBase}.local`;
+    const remotePath = `${packetBase}.remote`;
+    if (Object.prototype.hasOwnProperty.call(baseContents, change.path)) {
+      files[basePath] = baseContents[change.path] || '';
+    }
+    files[localPath] = localContents[change.path] || '';
+    files[remotePath] = remoteContents[change.path] || '';
+    summary.push(`- ${rel} (${change.status})`);
+    if (Object.prototype.hasOwnProperty.call(baseContents, change.path)) {
+      summary.push(`  - base: ${basePath}`);
+    }
+    summary.push(`  - local: ${localPath}`);
+    summary.push(`  - remote: ${remotePath}`);
+  }
+
+  files[`.atris/sync/conflicts/${timestamp}/summary.md`] = `${summary.join('\n')}\n`;
+  return { files, conflicts };
+}
+
+function writeConflictReviewPacket(rootDir, packet) {
+  const written = [];
+  for (const [relPath, content] of Object.entries((packet && packet.files) || {})) {
+    const fullPath = path.join(rootDir, relPath);
+    fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+    fs.writeFileSync(fullPath, content, 'utf8');
+    written.push(fullPath);
+  }
+  return written;
+}
+
+function readBaseContent(rootDir, cloudPath) {
+  try {
+    return fs.readFileSync(scopedSyncPath(rootDir, path.join('.atris', 'sync', 'base'), cloudPath), 'utf8');
+  } catch {
+    return null;
+  }
+}
+
+function writeBaseContents(rootDir, contents = {}) {
+  const written = [];
+  for (const [cloudPath, content] of Object.entries(contents)) {
+    if (typeof content !== 'string') continue;
+    const fullPath = scopedSyncPath(rootDir, path.join('.atris', 'sync', 'base'), cloudPath);
+    fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+    fs.writeFileSync(fullPath, content, 'utf8');
+    written.push(fullPath);
+  }
+  return written;
+}
+
+function removeBaseContents(rootDir, cloudPaths = []) {
+  for (const cloudPath of cloudPaths) {
+    fs.rmSync(scopedSyncPath(rootDir, path.join('.atris', 'sync', 'base'), cloudPath), { force: true });
+  }
+}
+
+module.exports = {
+  buildConflictReviewPacket,
+  classifyBrainSync,
+  classifyPath,
+  readBaseContent,
+  renderSyncSummary,
+  removeBaseContents,
+  writeBaseContents,
+  writeConflictReviewPacket,
+};

package/lib/manifest.js

@@ -47,10 +47,11 @@ function computeFileHash(content) {
  * Build a manifest object from a set of files.
  * files: { [path]: { hash, size } }
  */
-function buildManifest(files, commitHash) {
+function buildManifest(files, commitHash, metadata = {}) {
   return {
     last_sync: new Date().toISOString(),
     last_commit: commitHash || null,
+    workspace_root: metadata.workspaceRoot || null,
     files,
   };
 }

package/lib/task-db.js

@@ -1,6 +1,6 @@
 // SQLite-backed task store. node:sqlite (built-in, v22+).
-// Local state layer for `atris task`. TODO.md stays the human-readable
-// project board; this store gives agents atomic claims and a compact sync row.
+// Local state layer for `atris task`. TODO.md is a regenerated human-readable
+// view; this store gives agents atomic claims plus an append-only event trail.
 //
 // Path: ~/.atris/tasks.db (gitignored, never blobbed). Per-workspace scope via
 // workspace_root column. Rows survive across machines only when explicitly
@@ -29,6 +29,7 @@ const crypto = require('crypto');
 const { DatabaseSync } = require('node:sqlite');
 
 const DEFAULT_DB_PATH = path.join(os.homedir(), '.atris', 'tasks.db');
+const TASK_EPISODES_FILE = path.join('.atris', 'state', 'task_episodes.jsonl');
 
 const SCHEMA = `
 CREATE TABLE IF NOT EXISTS tasks (
@@ -45,9 +46,21 @@ CREATE TABLE IF NOT EXISTS tasks (
   done_at         INTEGER,
   metadata        TEXT
 );
+CREATE TABLE IF NOT EXISTS task_events (
+  event_id        TEXT PRIMARY KEY,
+  task_id         TEXT NOT NULL,
+  version         INTEGER NOT NULL,
+  workspace_root  TEXT NOT NULL,
+  actor           TEXT,
+  event_type      TEXT NOT NULL,
+  payload         TEXT,
+  created_at      INTEGER NOT NULL
+);
 CREATE INDEX IF NOT EXISTS idx_tasks_status      ON tasks(status);
 CREATE INDEX IF NOT EXISTS idx_tasks_workspace   ON tasks(workspace_root);
 CREATE INDEX IF NOT EXISTS idx_tasks_claimed_by  ON tasks(claimed_by);
+CREATE INDEX IF NOT EXISTS idx_task_events_task  ON task_events(task_id, version);
+CREATE INDEX IF NOT EXISTS idx_task_events_ws    ON task_events(workspace_root, created_at);
 CREATE UNIQUE INDEX IF NOT EXISTS uq_tasks_source ON tasks(workspace_root, source_key)
   WHERE source_key IS NOT NULL;
 `;
@@ -74,9 +87,9 @@ function open(dbPath) {
   withBusyRetry(() => db.exec('PRAGMA busy_timeout = 30000'));
   withBusyRetry(() => db.exec('PRAGMA foreign_keys = ON'));
   withBusyRetry(() => db.exec(SCHEMA));
-  // Schema version. Bump at every additive migration; tick 1 ships at v1.
+  // Schema version. Bump at every additive migration.
   // Future migrations read this and apply diffs idempotently.
-  withBusyRetry(() => db.exec('PRAGMA user_version = 1'));
+  withBusyRetry(() => db.exec('PRAGMA user_version = 2'));
   _cachedDb = db;
   _cachedPath = target;
   return db;
@@ -177,6 +190,19 @@ function addTask(db, { title, tag, workspaceRoot: ws, sourceKey: sk, metadata, s
     now,
     metadata ? JSON.stringify(metadata) : null,
   ));
+  appendTaskEvent(db, {
+    taskId: id,
+    workspaceRoot: ws,
+    actor: claimedBy || null,
+    eventType: taskStatus === 'claimed' ? 'claimed' : 'created',
+    payload: {
+      title: String(title).trim(),
+      tag: tag || null,
+      status: taskStatus,
+      source_key: sk || null,
+      metadata: metadata || null,
+    },
+  });
   return { id, inserted: true };
 }
 
@@ -201,6 +227,17 @@ function listTasks(db, { workspaceRoot: ws, status, claimedBy, limit }) {
   }));
 }
 
+function getTask(db, id) {
+  if (!id) throw new Error('id required');
+  const row = db.prepare(`
+    SELECT id, title, status, tag, workspace_root, source_key, claimed_by, claimed_at, created_at, updated_at, done_at, metadata
+    FROM tasks
+    WHERE id = ?
+  `).get(id);
+  if (!row) return null;
+  return { ...row, metadata: row.metadata ? safeJSON(row.metadata) : null };
+}
+
 // Atomic claim. Returns { claimed: true, row } only if THIS call won the row.
 // Race-safe via single UPDATE with WHERE status='open' guard. SQLite serializes
 // writes; busy_timeout absorbs contention. Caller must check `.claimed`.
@@ -220,6 +257,13 @@ function claimTask(db, { id, claimedBy }) {
   const result = withBusyRetry(() => stmt.run(claimedBy, now, now, id));
   if (result.changes === 1) {
     const row = db.prepare('SELECT * FROM tasks WHERE id = ?').get(id);
+    appendTaskEvent(db, {
+      taskId: id,
+      workspaceRoot: row.workspace_root,
+      actor: claimedBy,
+      eventType: 'claimed',
+      payload: { claimed_by: claimedBy },
+    });
     return { claimed: true, row: { ...row, metadata: row.metadata ? safeJSON(row.metadata) : null } };
   }
   // Either id doesn't exist or status != 'open'. Tell the caller which.
@@ -239,9 +283,225 @@ function doneTask(db, { id, status }) {
      WHERE id = ?
        AND status IN ('open', 'claimed')
   `).run(final, now, now, id));
+  if (result.changes === 1) {
+    const row = db.prepare('SELECT id, workspace_root FROM tasks WHERE id = ?').get(id);
+    appendTaskEvent(db, {
+      taskId: id,
+      workspaceRoot: row.workspace_root,
+      actor: process.env.ATRIS_AGENT_ID || process.env.USER || null,
+      eventType: final === 'done' ? 'completed' : 'blocked',
+      payload: { status: final },
+    });
+  }
   return { updated: result.changes === 1 };
 }
 
+function appendTaskEvent(db, { taskId, workspaceRoot: ws, actor, eventType, payload }) {
+  if (!taskId) throw new Error('taskId required');
+  if (!ws) throw new Error('workspaceRoot required');
+  if (!eventType) throw new Error('eventType required');
+  const current = db.prepare('SELECT MAX(version) AS version FROM task_events WHERE task_id = ?').get(taskId);
+  const version = Number(current && current.version || 0) + 1;
+  const eventId = newId();
+  const now = Date.now();
+  withBusyRetry(() => db.prepare(`
+    INSERT INTO task_events (event_id, task_id, version, workspace_root, actor, event_type, payload, created_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(
+    eventId,
+    taskId,
+    version,
+    ws,
+    actor || null,
+    eventType,
+    payload ? JSON.stringify(payload) : null,
+    now,
+  ));
+  return {
+    event_id: eventId,
+    task_id: taskId,
+    version,
+    workspace_root: ws,
+    actor: actor || null,
+    event_type: eventType,
+    payload: payload || null,
+    created_at: now,
+  };
+}
+
+function listTaskEvents(db, { taskId, workspaceRoot: ws, limit }) {
+  const where = [];
+  const args = [];
+  if (taskId) { where.push('task_id = ?'); args.push(taskId); }
+  if (ws) { where.push('workspace_root = ?'); args.push(ws); }
+  const sql = `
+    SELECT event_id, task_id, version, workspace_root, actor, event_type, payload, created_at
+    FROM task_events
+    ${where.length ? 'WHERE ' + where.join(' AND ') : ''}
+    ORDER BY created_at ASC, version ASC
+    ${limit ? 'LIMIT ' + Number(limit) : ''}
+  `;
+  return db.prepare(sql).all(...args).map(r => ({
+    ...r,
+    payload: r.payload ? safeJSON(r.payload) : null,
+  }));
+}
+
+function noteTask(db, { id, actor, content }) {
+  if (!id) throw new Error('id required');
+  const text = String(content || '').trim();
+  if (!text) throw new Error('content required');
+  const row = getTask(db, id);
+  if (!row) return { noted: false, reason: 'not_found' };
+  const event = appendTaskEvent(db, {
+    taskId: id,
+    workspaceRoot: row.workspace_root,
+    actor: actor || null,
+    eventType: 'message',
+    payload: { content: text },
+  });
+  return { noted: true, event };
+}
+
+function reviewTask(db, { id, actor, reward, lesson, nextTask, proof }) {
+  if (!id) throw new Error('id required');
+  const row = getTask(db, id);
+  if (!row) return { reviewed: false, reason: 'not_found' };
+  const numericReward = Number.isFinite(Number(reward)) ? Number(reward) : 0;
+  const payload = {
+    reward: numericReward,
+    lesson: String(lesson || '').trim(),
+    next_task: String(nextTask || '').trim() || null,
+    proof: String(proof || '').trim() || null,
+  };
+  const event = appendTaskEvent(db, {
+    taskId: id,
+    workspaceRoot: row.workspace_root,
+    actor: actor || null,
+    eventType: 'reviewed',
+    payload,
+  });
+  const episode = taskEpisodeFromReview(row, event, payload);
+  appendTaskEpisode(row.workspace_root, episode);
+  return { reviewed: true, event, episode };
+}
+
+function taskEpisodeFromReview(row, event, payload) {
+  return {
+    schema: 'atris.task_episode.v1',
+    episode_id: event.event_id,
+    task_id: row.id,
+    workspace_root: row.workspace_root,
+    created_at: new Date(event.created_at).toISOString(),
+    state: {
+      title: row.title,
+      status: row.status,
+      tag: row.tag,
+      claimed_by: row.claimed_by,
+      metadata: row.metadata || {},
+    },
+    action: {
+      event_type: 'reviewed',
+      actor: event.actor || null,
+      version: event.version,
+    },
+    reward: {
+      value: payload.reward,
+      source: 'task_review',
+    },
+    lesson: payload.lesson,
+    proof: payload.proof,
+    next_task_suggestion: payload.next_task,
+  };
+}
+
+function appendTaskEpisode(workspaceRoot, episode) {
+  const filePath = path.join(workspaceRoot, TASK_EPISODES_FILE);
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.appendFileSync(filePath, JSON.stringify(episode) + '\n', 'utf8');
+  return filePath;
+}
+
+function taskProjection(db, { workspaceRoot: ws, taskId, limit = 500 } = {}) {
+  const rows = taskId
+    ? [getTask(db, taskId)].filter(Boolean)
+    : listTasks(db, { workspaceRoot: ws || null, limit });
+  const events = listTaskEvents(db, {
+    taskId: taskId || null,
+    workspaceRoot: taskId ? null : (ws || null),
+    limit: limit * 20,
+  });
+  const byTask = new Map();
+  for (const e of events) {
+    if (!byTask.has(e.task_id)) byTask.set(e.task_id, []);
+    byTask.get(e.task_id).push(e);
+  }
+  return {
+    schema: 'atris.task_projection.v1',
+    generated_at: new Date().toISOString(),
+    workspace_root: ws || (rows[0] && rows[0].workspace_root) || null,
+    tasks: rows.map(row => {
+      const taskEvents = byTask.get(row.id) || [];
+      const latest = taskEvents.length ? taskEvents[taskEvents.length - 1] : null;
+      const messages = taskEvents
+        .filter(e => e.event_type === 'message')
+        .map(e => ({
+          version: e.version,
+          actor: e.actor,
+          content: e.payload && e.payload.content || '',
+          created_at: e.created_at,
+        }));
+      return {
+        id: row.id,
+        title: row.title,
+        status: row.status,
+        tag: row.tag,
+        workspace_root: row.workspace_root,
+        claimed_by: row.claimed_by,
+        created_at: row.created_at,
+        updated_at: row.updated_at,
+        done_at: row.done_at,
+        metadata: row.metadata || {},
+        current_version: latest ? latest.version : 0,
+        latest_event_type: latest ? latest.event_type : null,
+        messages,
+        events: taskEvents,
+      };
+    }),
+  };
+}
+
+function renderTodoMarkdown(rows, { title = 'TODO.md' } = {}) {
+  const buckets = {
+    open: rows.filter(r => r.status === 'open'),
+    claimed: rows.filter(r => r.status === 'claimed'),
+    failed: rows.filter(r => r.status === 'failed'),
+    done: rows.filter(r => r.status === 'done'),
+  };
+  const lines = [`# ${title}`, '', '> Regenerated from durable Atris task state. Do not treat this file as truth.', ''];
+  appendSection(lines, 'Backlog', buckets.open);
+  appendSection(lines, 'In Progress', buckets.claimed);
+  appendSection(lines, 'Blocked', buckets.failed);
+  appendSection(lines, 'Completed', buckets.done);
+  return lines.join('\n') + '\n';
+}
+
+function appendSection(lines, name, rows) {
+  lines.push(`## ${name}`, '');
+  if (!rows.length) {
+    lines.push('(Empty)', '');
+    return;
+  }
+  for (const row of rows) {
+    const tag = row.tag ? ` [${row.tag}]` : '';
+    lines.push(`- **[${row.id}]** ${row.title}${tag}`);
+    if (row.claimed_by && row.status === 'claimed') lines.push(`  **Claimed by:** ${row.claimed_by}`);
+    const meta = row.metadata || {};
+    if (meta.verify) lines.push(`  **Verify:** ${meta.verify}`);
+  }
+  lines.push('');
+}
+
 function safeJSON(s) {
   try { return JSON.parse(s); } catch { return null; }
 }
@@ -279,9 +539,16 @@ module.exports = {
   sourceKey,
   normalizeTitle,
   addTask,
+  getTask,
   listTasks,
   claimTask,
   doneTask,
+  noteTask,
+  reviewTask,
+  appendTaskEvent,
+  listTaskEvents,
+  taskProjection,
+  renderTodoMarkdown,
   newId,
   // Test surface
   _SCHEMA: SCHEMA,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atris",
-  "version": "3.14.0",
+  "version": "3.15.11",
   "description": "Atris — an operating system for intelligence. Integrates with any agent.",
   "main": "bin/atris.js",
   "bin": {
@@ -29,6 +29,7 @@
     "atris/team/researcher/MEMBER.md",
     "atris/team/_template/MEMBER.md",
     "atris/features/_templates/",
+    "atris/features/company-brain-sync/",
     "atris/policies/",
     "atris/skills/"
   ],
@@ -56,5 +57,14 @@
   "repository": {
     "type": "git",
     "url": "git+https://github.com/atrislabs/atris.git"
-  }
+  },
+  "directories": {
+    "lib": "lib",
+    "test": "test"
+  },
+  "type": "commonjs",
+  "bugs": {
+    "url": "https://github.com/atrislabs/atris/issues"
+  },
+  "homepage": "https://github.com/atrislabs/atris#readme"
 }