atris 3.1.0 → 3.5.0

package/commands/wiki.js

@@ -5,11 +5,17 @@ const { apiRequestJson } = require('../utils/api');
 const { loadBusinesses, saveBusinesses } = require('./business');
 const {
   WIKI_ROOT,
+  PRIVATE_WIKI_ROOT,
+  getWikiRoot,
   ensureWikiScaffold,
+  ensureContextScaffold,
   findLocalWikiDir,
+  stageWikiIngest,
   buildIngestPrompt,
   buildQueryPrompt,
   buildLintPrompt,
+  writeWikiStatus,
+  appendWikiLog,
 } = require('../lib/wiki');
 
 function autoDetectSlug() {
@@ -31,9 +37,14 @@ function parseCloudArgs(args) {
 
 function parseModeArgs(args) {
   const cloud = args.includes('--cloud');
+  const privateMode = args.includes('--private');
+  if (cloud && privateMode) {
+    console.error('Use either --cloud or --private, not both.');
+    process.exit(1);
+  }
   return {
-    mode: cloud ? 'cloud' : 'local',
-    args: args.filter((arg) => arg !== '--cloud' && arg !== '--local'),
+    mode: cloud ? 'cloud' : (privateMode ? 'private' : 'local'),
+    args: args.filter((arg) => arg !== '--cloud' && arg !== '--local' && arg !== '--private'),
   };
 }
 
@@ -142,10 +153,10 @@ async function runChat(business, prompt, token) {
   }
 }
 
-function printLocalPrompt(title, prompt, details = []) {
+function printLocalPrompt(title, prompt, wikiRoot, details = []) {
   console.log('');
   console.log(title);
-  console.log(`Target: ${WIKI_ROOT}`);
+  console.log(`Target: ${wikiRoot}`);
   details.forEach((detail) => console.log(detail));
   console.log('');
   console.log('Prompt for the current coding agent:');
@@ -160,11 +171,33 @@ async function wikiIngest(mode, slug, sourceValue) {
     process.exit(1);
   }
 
-  if (mode === 'local') {
-    const wikiDir = ensureWikiScaffold();
-    printLocalPrompt('Local wiki ingest', buildIngestPrompt(sourceValue), [
+  if (mode === 'local' || mode === 'private') {
+    const wikiMode = mode === 'private' ? 'private' : 'public';
+    const wikiDir = ensureWikiScaffold(process.cwd(), wikiMode);
+    const contextDir = ensureContextScaffold(process.cwd(), wikiMode);
+    const staged = stageWikiIngest(process.cwd(), sourceValue, wikiMode);
+    writeWikiStatus(process.cwd(), {
+      health: `ingest staged from ${staged.packPath}`,
+      nextMove: `compile ${staged.promptSource} into ${getWikiRoot(wikiMode)}`,
+    }, wikiMode, { lastIngest: staged.manifest.ingested_at });
+    appendWikiLog(
+      process.cwd(),
+      `${staged.manifest.entries.length} source item(s) staged from ${sourceValue}`,
+      [
+        `context ${contextDir}`,
+        `pack ${staged.packPath}`,
+        `manifest ${staged.manifestPath}`,
+        ...staged.manifest.entries.map((entry) => `${entry.kind} ${entry.staged}`),
+      ],
+      wikiMode,
+      'INGEST'
+    );
+    printLocalPrompt(mode === 'private' ? 'Private wiki ingest' : 'Local wiki ingest', buildIngestPrompt(staged.promptSource, wikiMode), getWikiRoot(wikiMode), [
       `Wiki dir: ${wikiDir}`,
-      `Sources: ${sourceValue}`,
+      `Context dir: ${contextDir}`,
+      `Pack: ${staged.packPath}`,
+      `Manifest: ${staged.manifestPath}`,
+      `Sources: ${staged.promptSource}`,
     ]);
     return;
   }
@@ -182,13 +215,14 @@ async function wikiQuery(mode, slug, question) {
     process.exit(1);
   }
 
-  if (mode === 'local') {
-    const wikiDir = findLocalWikiDir(process.cwd(), slug);
+  if (mode !== 'cloud') {
+    const wikiMode = mode === 'private' ? 'private' : 'public';
+    const wikiDir = findLocalWikiDir(process.cwd(), slug, wikiMode);
     if (!wikiDir) {
-      console.error('No local atris/wiki found. Run: atris ingest <path>');
+      console.error(`No local wiki found at ${getWikiRoot(wikiMode)}. Run: atris wiki ingest${wikiMode === 'private' ? ' --private' : ''} <path>`);
       process.exit(1);
     }
-    printLocalPrompt('Local wiki query', buildQueryPrompt(question), [
+    printLocalPrompt(mode === 'private' ? 'Private wiki query' : 'Local wiki query', buildQueryPrompt(question, wikiMode), getWikiRoot(wikiMode), [
       `Wiki dir: ${wikiDir}`,
       `Question: ${question}`,
     ]);
@@ -201,13 +235,14 @@ async function wikiQuery(mode, slug, question) {
 }
 
 async function wikiLint(mode, slug) {
-  if (mode === 'local') {
-    const wikiDir = findLocalWikiDir(process.cwd(), slug);
+  if (mode !== 'cloud') {
+    const wikiMode = mode === 'private' ? 'private' : 'public';
+    const wikiDir = findLocalWikiDir(process.cwd(), slug, wikiMode);
     if (!wikiDir) {
-      console.error('No local atris/wiki found. Run: atris ingest <path>');
+      console.error(`No local wiki found at ${getWikiRoot(wikiMode)}. Run: atris wiki ingest${wikiMode === 'private' ? ' --private' : ''} <path>`);
       process.exit(1);
     }
-    printLocalPrompt('Local wiki lint', buildLintPrompt(), [`Wiki dir: ${wikiDir}`]);
+    printLocalPrompt(mode === 'private' ? 'Private wiki lint' : 'Local wiki lint', buildLintPrompt(wikiMode), getWikiRoot(wikiMode), [`Wiki dir: ${wikiDir}`]);
     return;
   }
 
@@ -217,15 +252,16 @@ async function wikiLint(mode, slug) {
   await runChat(business, buildLintPrompt(), creds.token);
 }
 
-function wikiSearch(slug, query) {
+function wikiSearch(mode, slug, query) {
   if (!query) {
     console.error('Usage: atris wiki search [business] <term>');
     process.exit(1);
   }
 
-  const wikiDir = findLocalWikiDir(process.cwd(), slug);
+  const wikiMode = mode === 'private' ? 'private' : 'public';
+  const wikiDir = findLocalWikiDir(process.cwd(), slug, wikiMode);
   if (!wikiDir) {
-    console.error(`No local wiki found. Run: atris pull ${slug || ''} --only wiki`);
+    console.error(`No local wiki found at ${getWikiRoot(wikiMode)}.`);
     process.exit(1);
   }
 
@@ -250,10 +286,11 @@ function wikiSearch(slug, query) {
   console.log('');
 }
 
-function wikiLog(slug, limit) {
-  const wikiDir = findLocalWikiDir(process.cwd(), slug);
+function wikiLog(mode, slug, limit) {
+  const wikiMode = mode === 'private' ? 'private' : 'public';
+  const wikiDir = findLocalWikiDir(process.cwd(), slug, wikiMode);
   if (!wikiDir) {
-    console.error(`No local wiki found. Run: atris pull ${slug || ''} --only wiki`);
+    console.error(`No local wiki found at ${getWikiRoot(wikiMode)}.`);
     process.exit(1);
   }
 
@@ -314,14 +351,21 @@ async function wikiCommand(subcommand, ...args) {
       break;
     }
     case 'search': {
-      const [slug, query] = parseCloudArgs(cleanArgs);
-      wikiSearch(slug, query);
+      if (mode === 'private') {
+        wikiSearch(mode, null, cleanArgs.join(' '));
+      } else {
+        const [slug, query] = parseCloudArgs(cleanArgs);
+        wikiSearch(mode, slug, query);
+      }
       break;
     }
     case 'log': {
       let slug;
       let limit;
-      if (cleanArgs.length === 0) {
+      if (mode === 'private') {
+        slug = null;
+        limit = parseInt(cleanArgs[0], 10) || 20;
+      } else if (cleanArgs.length === 0) {
         slug = autoDetectSlug();
         limit = 20;
       } else if (cleanArgs.length === 1) {
@@ -336,7 +380,7 @@ async function wikiCommand(subcommand, ...args) {
         slug = cleanArgs[0];
         limit = parseInt(cleanArgs[1], 10) || 20;
       }
-      wikiLog(slug, limit);
+      wikiLog(mode, slug, limit);
       break;
     }
     case 'loop': {
@@ -361,6 +405,7 @@ async function wikiCommand(subcommand, ...args) {
       console.log('Flags:');
       console.log('  --cloud                       Route ingest/query/lint to the cloud workspace');
       console.log('  --local                       Be explicit about local mode');
+      console.log(`  --private                     Use local private wiki at ${PRIVATE_WIKI_ROOT}/`);
       console.log('');
       console.log('Business is auto-detected from .atris/business.json for cloud mode if omitted.');
   }

package/lib/file-ops.js

@@ -1,7 +1,11 @@
 const fs = require('fs');
 const path = require('path');
 
-// Log file operations
+/**
+ * Get the path components for a journal log file.
+ * @param {string} [dateStr] - Optional date string (defaults to today)
+ * @returns {Object} Object with logsDir, yearDir, logFile, dateFormatted
+ */
 function getLogPath(dateStr) {
   const targetDir = path.join(process.cwd(), 'atris');
   const date = dateStr ? new Date(dateStr) : new Date();
@@ -17,6 +21,9 @@ function getLogPath(dateStr) {
   return { logsDir, yearDir, logFile, dateFormatted };
 }
 
+/**
+ * Ensure the logs directory structure exists.
+ */
 function ensureLogDirectory() {
   const { logsDir, yearDir } = getLogPath();
 
@@ -29,6 +36,11 @@ function ensureLogDirectory() {
   }
 }
 
+/**
+ * Create a new daily log file, carrying forward unfinished items from yesterday.
+ * @param {string} logFile - Path to the log file to create
+ * @param {string} dateFormatted - Date string in YYYY-MM-DD format
+ */
 function createLogFile(logFile, dateFormatted) {
   let carryInProgress = '';
   let carryBacklog = '';

package/lib/journal.js

@@ -4,6 +4,12 @@ const path = require('path');
 const os = require('os');
 const { spawnSync } = require('child_process');
 
+/**
+ * Check if two timestamps are effectively the same (within 5ms).
+ * @param {string} a - First timestamp
+ * @param {string} b - Second timestamp
+ * @returns {boolean} True if timestamps are within 5ms of each other
+ */
 function isSameTimestamp(a, b) {
   if (!a || !b) return false;
   const ta = new Date(a).getTime();
@@ -12,6 +18,11 @@ function isSameTimestamp(a, b) {
   return Math.abs(ta - tb) < 5;
 }
 
+/**
+ * Compute a SHA-256 hash of content with normalized line endings.
+ * @param {string} content - Content to hash
+ * @returns {string|null} Hex hash or null if invalid input
+ */
 function computeContentHash(content) {
   if (typeof content !== 'string') {
     return null;
@@ -20,6 +31,11 @@ function computeContentHash(content) {
   return crypto.createHash('sha256').update(normalized).digest('hex');
 }
 
+/**
+ * Parse journal content into named sections (by ## headers).
+ * @param {string} content - Journal markdown content
+ * @returns {Object} Map of section name to content
+ */
 function parseJournalSections(content) {
   const sections = {};
   const lines = content.split('\n');
@@ -48,6 +64,13 @@ function parseJournalSections(content) {
   return sections;
 }
 
+/**
+ * Merge local and remote journal sections, detecting conflicts.
+ * @param {Object} localSections - Local section map
+ * @param {Object} remoteSections - Remote section map
+ * @param {string} knownRemoteHash - Hash of remote at last sync
+ * @returns {{merged: Object, conflicts: Array}} Merged sections and conflicts
+ */
 function mergeSections(localSections, remoteSections, knownRemoteHash) {
   const merged = {};
   const conflicts = [];

package/lib/reward-config.js

@@ -0,0 +1,24 @@
+/**
+ * Frozen reward constants for the RL loop.
+ *
+ * These live outside mutable repo state so the loop cannot edit its own
+ * judge.  REWARD_CHECKSUM is the SHA-256 of JSON.stringify(REWARD_CONFIG)
+ * + computeTickReward.toString() at ship time — if the config values or
+ * function body change, verifyJudgeIntegrity() halts the next tick.
+ */
+
+const crypto = require('crypto');
+
+const REWARD_CONFIG = Object.freeze({
+  REVIEW_CLEAN:   1,
+  VERIFY_PASS:    3,
+  NPM_TEST_BONUS: 2,
+  COMMIT_LANDED:  1,
+  HALT_PENALTY:  -3,
+});
+
+// SHA-256 of JSON.stringify(REWARD_CONFIG) + computeTickReward.toString() at ship time.
+// Regenerate: node -e "const c=require('./lib/reward-config');const h=require('crypto').createHash('sha256');h.update(JSON.stringify(c.REWARD_CONFIG));h.update(require('./commands/autopilot').computeTickReward.toString());console.log(h.digest('hex'))"
+const REWARD_CHECKSUM = '5a84be0f7f392d6ef05337be0776f864852e94d6391da0b41486298555595a40';
+
+module.exports = { REWARD_CONFIG, REWARD_CHECKSUM };

package/lib/scorecard.js

@@ -2,6 +2,33 @@ const fs = require('fs');
 const path = require('path');
 const { parseTodo } = require('./todo');
 
+const PRIVATE_MEMORY_ROOT = '.atris/presidio';
+
+/**
+ * Ensure the private memory directory exists.
+ * @param {string} atrisDir - Path to the atris directory
+ * @returns {string} Path to the private memory directory
+ */
+function ensurePrivateMemoryDir(atrisDir) {
+  const privateDir = path.join(path.dirname(atrisDir), PRIVATE_MEMORY_ROOT);
+  fs.mkdirSync(privateDir, { recursive: true });
+  return privateDir;
+}
+
+/**
+ * Get the path to the scorecards file.
+ * @param {string} atrisDir - Path to the atris directory
+ * @returns {string} Path to scorecards.md
+ */
+function getScorecardsPath(atrisDir) {
+  return path.join(ensurePrivateMemoryDir(atrisDir), 'scorecards.md');
+}
+
+/**
+ * Parse a "picked at" timestamp from scorecard data.
+ * @param {string} value - Timestamp string in YYYY-MM-DD [HH:MM] format
+ * @returns {Date|null} Parsed date or null if invalid
+ */
 function parsePickedAt(value) {
   if (!value) return null;
   const match = String(value).trim().match(/^(\d{4}-\d{2}-\d{2})(?:\s+(\d{2}:\d{2}))?/);
@@ -12,6 +39,12 @@ function parsePickedAt(value) {
   return Number.isNaN(parsed.getTime()) ? null : parsed;
 }
 
+/**
+ * Parse a tick timestamp combining date and time label.
+ * @param {string} dateStr - Date in YYYY-MM-DD format
+ * @param {string} timeLabel - Time label like "2:30 PM"
+ * @returns {Date|null} Parsed date or null if invalid
+ */
 function parseTickDate(dateStr, timeLabel) {
   const match = String(timeLabel || '').trim().toLowerCase().match(/^(\d{1,2}):(\d{2})(?:\s*(am|pm))?$/);
   if (!match) return null;
@@ -28,6 +61,13 @@ function parseTickDate(dateStr, timeLabel) {
   return Number.isNaN(parsed.getTime()) ? null : parsed;
 }
 
+/**
+ * List journal log files within a date range.
+ * @param {string} atrisDir - Path to the atris directory
+ * @param {Date} startDate - Start of date range
+ * @param {Date} [endDate] - End of date range (defaults to today)
+ * @returns {Array} Array of log file paths
+ */
 function listLogFiles(atrisDir, startDate, endDate = new Date()) {
   const logsDir = path.join(atrisDir, 'logs');
   if (!fs.existsSync(logsDir)) return [];
@@ -141,16 +181,20 @@ function buildScorecardData(atrisDir, { slug, pickedAt } = {}) {
   const todo = parseTodo(todoPath);
   const startAt = parsePickedAt(pickedAt) || new Date();
   const rewardStats = collectRewardStats(atrisDir, pickedAt);
-  const completedEndgame = todo.completed.filter(t => t.tag === 'endgame').length;
+  // Count shipped tasks from journal completions (tasks get deleted from TODO.md after completion)
+  const completedFromTodo = todo.completed.filter(t => t.tag === 'endgame').length;
   const activeEndgame = todo.backlog.filter(t => t.tag === 'endgame').length
     + todo.inProgress.filter(t => t.tag === 'endgame').length;
+  // Fall back to reward tick count if TODO completions were already pruned
+  const shipped = completedFromTodo > 0 ? completedFromTodo : rewardStats.totalTicks - rewardStats.haltedTicks;
+  const attempted = shipped + activeEndgame + rewardStats.haltedTicks;
 
   return {
     slug,
     startDate: startAt.toISOString().slice(0, 10),
     endDate: new Date().toISOString().slice(0, 10),
-    tasksShipped: completedEndgame,
-    tasksAttempted: completedEndgame + activeEndgame,
+    tasksShipped: Math.max(shipped, 0),
+    tasksAttempted: Math.max(attempted, shipped),
     wallClockHours: Math.max(0, (Date.now() - startAt.getTime()) / (1000 * 60 * 60)),
     haltRatio: rewardStats.totalTicks > 0 ? rewardStats.haltedTicks / rewardStats.totalTicks : 0,
     totalReward: rewardStats.totalReward,
@@ -191,7 +235,13 @@ function writeScorecard(atrisDir, data) {
     throw new Error('Scorecard: slug is required');
   }
 
-  const scorecardsPath = path.join(atrisDir, 'scorecards.md');
+  const scorecardsPath = getScorecardsPath(atrisDir);
+
+  // Dedupe guard: don't write the same slug twice
+  const existing = readScorecards(atrisDir);
+  if (existing.some(sc => sc.slug === slug)) {
+    return; // already written
+  }
 
   // Ensure scorecards.md exists
   if (!fs.existsSync(scorecardsPath)) {
@@ -244,14 +294,14 @@ function detectEndgameCompletion(atrisDir) {
  * Parse scorecards.md and return array of scorecard objects.
  */
 function readScorecards(atrisDir) {
-  const scorecardsPath = path.join(atrisDir, 'scorecards.md');
+  const scorecardsPath = getScorecardsPath(atrisDir);
   if (!fs.existsSync(scorecardsPath)) return [];
 
   const content = fs.readFileSync(scorecardsPath, 'utf8');
   const scorecards = [];
 
   for (const line of content.split('\n')) {
-    const match = line.match(/^- \*\*\[(.+?)\]\s+(.+?)\*\*\s*—\s*shipped:\s*(\d+)\/(\d+)\s*—\s*wall-clock:\s*(.+?)\s*—\s*halt:\s*(\d+)%\s*—\s*reward:\s*(\d+)\s*—\s*lessons:\s*(\d+)$/);
+    const match = line.match(/^- \*\*\[(.+?)\]\s+(.+?)\*\*\s*—\s*shipped:\s*(\d+)\/(\d+)\s*—\s*wall-clock:\s*(.+?)\s*—\s*halt:\s*(\d+)%\s*—\s*reward:\s*(-?\d+)\s*—\s*lessons:\s*(\d+)$/);
     if (!match) continue;
 
     const [, endDate, slug, shipped, attempted, wallClockStr, haltPercent, reward, lessons] = match;
@@ -280,6 +330,8 @@ function readScorecards(atrisDir) {
 }
 
 module.exports = {
+  PRIVATE_MEMORY_ROOT,
+  getScorecardsPath,
   buildScorecardData,
   writeScorecard,
   readScorecards,

package/lib/sync-telemetry.js

@@ -0,0 +1,59 @@
+// Atris sync telemetry — emit one event per `atris push` / `atris pull`.
+//
+// Why awaited (not fire-and-forget): push.js / pull.js call process.exit(1)
+// on most failure paths. A fire-and-forget POST gets killed mid-flight and
+// the RL loop loses signals on the exact failures it most needs to learn.
+//
+// Best-effort: any error swallowed silently — telemetry never blocks UX.
+// Hard 2s timeout so a flaky control plane can't slow real operations.
+
+const { apiRequestJson } = require('../utils/api');
+
+let _cachedVersion = null;
+function cliVersion() {
+  if (_cachedVersion) return _cachedVersion;
+  try {
+    _cachedVersion = require('../package.json').version || 'unknown';
+  } catch {
+    _cachedVersion = 'unknown';
+  }
+  return _cachedVersion;
+}
+
+async function emitSyncEvent(token, businessId, workspaceId, op, outcome, latencyMs, extras = {}) {
+  if (!token || !businessId || !workspaceId || !op || !outcome) return false;
+  const event = {
+    business_id: businessId,
+    workspace_id: workspaceId,
+    op,
+    outcome,
+    latency_ms: Math.max(0, Math.round(latencyMs || 0)),
+    bytes_transferred: extras.bytes_transferred || 0,
+    bytes_changed: extras.bytes_changed || 0,
+    files_pushed: extras.files_pushed || 0,
+    files_deleted: extras.files_deleted || 0,
+    files_unchanged: extras.files_unchanged || 0,
+    cli_version: cliVersion(),
+  };
+  if (extras.error_detail) event.error_detail = String(extras.error_detail).slice(0, 500);
+
+  try {
+    await apiRequestJson('/atris-sync/telemetry', {
+      method: 'POST',
+      token,
+      body: event,
+      timeoutMs: 2000,
+      retries: 0,
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function startTimer() {
+  const t0 = Date.now();
+  return () => Date.now() - t0;
+}
+
+module.exports = { emitSyncEvent, startTimer };

package/lib/todo.js

@@ -17,6 +17,12 @@ function parseTodo(todoPath) {
   };
 }
 
+/**
+ * Parse a specific section from TODO.md content into task objects.
+ * @param {string} content - Full TODO.md content
+ * @param {string} sectionName - Section name to extract (e.g., 'Backlog')
+ * @returns {Array} Array of parsed task objects
+ */
 function parseSection(content, sectionName) {
   const escaped = sectionName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
   const match = content.match(new RegExp(`##\\s+${escaped}\\n([\\s\\S]*?)(?=\\n##|$)`, 'i'));