atris 1.5.2 → 1.5.4

package/README.md

@@ -10,7 +10,7 @@ See [`ENGINEERING_CYCLE.md`](./ENGINEERING_CYCLE.md) for the full vision.
 atris init → atris brainstorm → atris plan → atris do → atris review → atris launch
 ```
 
-Each command provides clear instruction prompts for your coding agent (Claude Code, Cursor, etc.).
+Each command provides clear instruction prompts for your coding agent (Cursor, Claude, etc.).
 
 ---
 
@@ -79,7 +79,7 @@ Need a structured prompt for an agent-led ideation session?
 atris brainstorm
 ```
 
-Answer a couple quick questions, get a ready-to-send conversation opener for Claude Code (with context + ASCII cue), and optionally log the session summary plus next steps.
+Answer a couple quick questions, get a ready-to-send conversation opener for your coding agent (with context + ASCII cue), and optionally log the session summary plus next steps.
 
 ---
 

package/commands/auth.js

@@ -0,0 +1,134 @@
+const { loadCredentials, saveCredentials, deleteCredentials, getCredentialsPath, openBrowser, promptUser, displayAccountSummary } = require('../utils/auth');
+const { getAppBaseUrl, apiRequestJson } = require('../utils/api');
+
+async function loginAtris() {
+  
+  try {
+    console.log('🔐 Login to AtrisOS\n');
+
+    const existing = loadCredentials();
+    if (existing) {
+      const label = existing.email || existing.user_id || 'unknown user';
+      console.log(`Already logged in as: ${label}`);
+      const confirm = await promptUser('Do you want to login again? (y/N): ');
+      if (confirm.toLowerCase() !== 'y') {
+        console.log('Login cancelled.');
+        process.exit(0);
+      }
+    }
+
+    console.log('Choose login method:');
+    console.log('  1. Browser OAuth (recommended)');
+    console.log('  2. Paste existing API token');
+    console.log('  3. Cancel');
+
+    const choice = await promptUser('\nEnter choice (1-3): ');
+
+    if (choice === '1') {
+      const loginUrl = `${getAppBaseUrl()}/auth/cli`;
+      console.log('\n🌐 Opening browser for OAuth login…');
+      console.log('If it does not open automatically, visit:');
+      console.log(loginUrl);
+      console.log('\nAfter signing in, copy the CLI code shown in the browser and paste it below.');
+      console.log('Codes expire after five minutes.\n');
+
+      openBrowser(loginUrl);
+
+      const code = await promptUser('Paste the CLI code here: ');
+      if (!code) {
+        console.error('✗ Error: Code is required');
+        process.exit(1);
+      }
+
+      const exchange = await apiRequestJson('/auth/cli/exchange', {
+        method: 'POST',
+        body: { code: code.trim() },
+      });
+
+      if (!exchange.ok || !exchange.data) {
+        console.error(`✗ Error: ${exchange.error || 'Invalid or expired code'}`);
+        process.exit(1);
+      }
+
+      const payload = exchange.data;
+      const token = payload.token;
+      const refreshToken = payload.refresh_token;
+
+      if (!token || !refreshToken) {
+        console.error('✗ Error: Backend did not return tokens. Please try again.');
+        process.exit(1);
+      }
+
+      const email = payload.email || existing?.email || null;
+      const userId = payload.user_id || existing?.user_id || null;
+      const provider = payload.provider || 'atris';
+
+      saveCredentials(token, refreshToken, email, userId, provider);
+      console.log('\n✓ Successfully logged in!');
+      await displayAccountSummary(apiRequestJson);
+      console.log('\nYou can now use cloud features with atris commands.');
+      process.exit(0);
+    } else if (choice === '2') {
+      console.log('\n📋 Manual Token Entry');
+      console.log('Get your token from: https://app.atris.ai/settings/api\n');
+
+      const tokenInput = await promptUser('Paste your API token: ');
+
+      if (!tokenInput) {
+        console.error('✗ Error: Token is required');
+        process.exit(1);
+      }
+
+      const trimmed = tokenInput.trim();
+      saveCredentials(trimmed, null, existing?.email || null, existing?.user_id || null, existing?.provider || 'manual');
+      console.log('\nAttempting to validate token…\n');
+
+      const summary = await displayAccountSummary(apiRequestJson);
+      if (summary.error) {
+        console.log('\n⚠️ Token saved, but validation failed. You may need to relogin.');
+      } else {
+        console.log('\n✓ Token validated successfully.');
+      }
+
+      console.log('\nYou can now use cloud features with atris commands.');
+      process.exit(0);
+    } else {
+      console.log('Login cancelled.');
+      process.exit(0);
+    }
+  } catch (error) {
+    console.error(`\n✗ Login failed: ${error.message || error}`);
+    process.exit(1);
+  }
+}
+
+function logoutAtris() {
+  const credentials = loadCredentials();
+
+  if (!credentials) {
+    console.log('Not currently logged in.');
+    process.exit(0);
+  }
+
+  deleteCredentials();
+  console.log('✓ Successfully logged out');
+  console.log(`✓ Removed credentials from ${getCredentialsPath()}`);
+}
+
+async function whoamiAtris() {
+  const { apiRequestJson } = require('../utils/api');
+  
+  try {
+    const summary = await displayAccountSummary(apiRequestJson);
+    if (summary.error) {
+      console.log('\nRun "atris login" to authenticate with AtrisOS.');
+      process.exit(1);
+    }
+    process.exit(0);
+  } catch (error) {
+    console.error(`✗ Failed to fetch account details: ${error.message || error}`);
+    process.exit(1);
+  }
+}
+
+module.exports = { loginAtris, logoutAtris, whoamiAtris };

package/commands/brainstorm.js

@@ -0,0 +1,169 @@
+const fs = require('fs');
+const path = require('path');
+const { getLogPath, ensureLogDirectory, createLogFile, parseInboxItems, addInboxIdea, removeInboxItemFromContent, recordBrainstormSession } = require('../lib/file-ops');
+const { loadConfig } = require('../utils/config');
+const { loadCredentials } = require('../utils/auth');
+const { apiRequestJson } = require('../utils/api');
+
+function brainstormAbortError() {
+  const error = new Error('Brainstorm cancelled by user.');
+  error.__brainstormAbort = true;
+  return error;
+}
+
+async function brainstormAtris() {
+  // Check for args: atris brainstorm "topic" --outcome "..." --vibe "..." --constraints "..."
+  const args = process.argv.slice(3);
+  let topicArg = null;
+  let outcomeArg = null;
+  let vibeArg = null;
+  let constraintsArg = null;
+  
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--outcome' && args[i + 1]) {
+      outcomeArg = args[i + 1];
+      i++;
+    } else if (args[i] === '--vibe' && args[i + 1]) {
+      vibeArg = args[i + 1];
+      i++;
+    } else if (args[i] === '--constraints' && args[i + 1]) {
+      constraintsArg = args[i + 1];
+      i++;
+    } else if (!args[i].startsWith('--') && !topicArg) {
+      topicArg = args[i];
+    }
+  }
+  const targetDir = path.join(process.cwd(), 'atris');
+  if (!fs.existsSync(targetDir)) {
+    throw new Error('atris/ folder not found. Run "atris init" first.');
+  }
+
+  ensureLogDirectory();
+  const { logFile, dateFormatted } = getLogPath();
+  if (!fs.existsSync(logFile)) {
+    createLogFile(logFile, dateFormatted);
+  }
+
+  // Show current stats for game-like feel
+  let todayStats = { completions: 0, inbox: 0 };
+  if (fs.existsSync(logFile)) {
+    const logContent = fs.readFileSync(logFile, 'utf8');
+    const completionMatches = logContent.match(/- \*\*C\d+:/g);
+    todayStats.completions = completionMatches ? completionMatches.length : 0;
+    const inboxMatch = logContent.match(/## Inbox\n([\s\S]*?)(?=\n##|---)/);
+    if (inboxMatch && inboxMatch[1].trim()) {
+      const inboxMatches = inboxMatch[1].match(/- \*\*I\d+:/g);
+      todayStats.inbox = inboxMatches ? inboxMatches.length : 0;
+    }
+  }
+
+  console.log('');
+  console.log('┌─────────────────────────────────────────────────────────────┐');
+  console.log('│ ATRIS Brainstorm — structured prompt generator              │');
+  console.log('└─────────────────────────────────────────────────────────────┘');
+  console.log('');
+  console.log(`📅 Date: ${dateFormatted}`);
+  console.log(`📊 Today: ${todayStats.completions} completions | ${todayStats.inbox} inbox items`);
+  console.log('💡 Type "exit" at any prompt to cancel.');
+  console.log('');
+
+  // Try to fetch latest journal entry from backend (optional)
+  let journalContext = '';
+  const config = loadConfig();
+  const credentials = loadCredentials();
+  
+  if (config.agent_id && credentials && credentials.token) {
+    try {
+      console.log('📖 Fetching latest journal entry from AtrisOS...');
+      const journalResult = await apiRequestJson(`/agents/${config.agent_id}/journal/today`, {
+        method: 'GET',
+        token: credentials.token,
+      });
+      
+      if (journalResult.ok && journalResult.data?.content) {
+        journalContext = journalResult.data.content;
+        console.log('✓ Loaded journal entry from backend');
+      } else {
+        const listResult = await apiRequestJson(`/agents/${config.agent_id}/journal/?limit=1`, {
+          method: 'GET',
+          token: credentials.token,
+        });
+        
+        if (listResult.ok && listResult.data?.entries?.length > 0) {
+          journalContext = listResult.data.entries[0].content || '';
+          console.log('✓ Loaded latest journal entry from backend');
+        }
+      }
+    } catch (error) {
+      console.log('ℹ️  Using local journal file (backend unavailable)');
+    }
+    console.log('');
+  }
+
+  // Fallback to local log file if no backend context
+  if (!journalContext) {
+    if (fs.existsSync(logFile)) {
+      journalContext = fs.readFileSync(logFile, 'utf8');
+    }
+  }
+
+  // Determine topic and inputs
+  let selectedInboxItem = null;
+  let topicSummary = topicArg || '';
+  let userStory = outcomeArg || '';
+  let feelingsVibe = vibeArg || '';
+  let constraints = constraintsArg || '';
+
+  // If no args provided, use inbox or prompt user
+  if (!topicArg) {
+    const initialContent = journalContext || (fs.existsSync(logFile) ? fs.readFileSync(logFile, 'utf8') : '');
+    let inboxItems = parseInboxItems(initialContent);
+    
+    if (inboxItems.length > 0) {
+      // Use first inbox item if available
+      selectedInboxItem = inboxItems[0];
+      topicSummary = selectedInboxItem.text;
+      console.log(`📌 Using inbox item I${selectedInboxItem.id}: ${topicSummary}`);
+    } else {
+      throw new Error('No topic provided. Usage: atris brainstorm "topic" [--outcome "..."] [--vibe "..."] [--constraints "..."]');
+    }
+  } else {
+    // Add new idea to inbox
+    const newId = addInboxIdea(logFile, topicSummary);
+    selectedInboxItem = { id: newId, text: topicSummary };
+    console.log(`✓ Added I${newId} to today's Inbox.`);
+  }
+
+  const sourceLabel = selectedInboxItem ? `I${selectedInboxItem.id}` : 'Ad-hoc';
+
+  // Build the brainstorm message (structured for AI to read)
+  const brainstormMessage = [
+    `I want to brainstorm: ${topicSummary}`,
+    '',
+    userStory ? `The outcome should be: ${userStory}` : '',
+    feelingsVibe ? `Vibe we're going for: ${feelingsVibe}` : '',
+    journalContext ? `Recent context from journal:\n${journalContext.substring(0, 500)}${journalContext.length > 500 ? '...' : ''}` : '',
+    constraints ? `Constraints: ${constraints}` : '',
+    '',
+    'Help me uncover what we need to build. Keep responses short (4-5 sentences), pause for alignment, sketch ASCII when structure helps.',
+  ].filter(line => line !== '').join('\n');
+
+  console.log('');
+  console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+  console.log('🧠 BRAINSTORM SESSION READY');
+  console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+  console.log('');
+  console.log('📝 Instructions for your coding agent:');
+  console.log('');
+  console.log(brainstormMessage);
+  console.log('');
+  console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+  console.log('');
+  console.log('💡 Your coding agent (in Cursor/IDE) should read the above and');
+  console.log('   start brainstorming with you here in the chat interface.');
+  console.log('   Keep it conversational, short responses, ASCII diagrams when helpful.');
+  console.log('');
+  console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+}
+
+module.exports = { brainstormAtris };

package/commands/init.js

@@ -0,0 +1,104 @@
+const fs = require('fs');
+const path = require('path');
+
+function initAtris() {
+  const targetDir = path.join(process.cwd(), 'atris');
+  const agentTeamDir = path.join(targetDir, 'agent_team');
+  const sourceFile = path.join(__dirname, '..', 'atris.md');
+  const targetFile = path.join(targetDir, 'atris.md');
+
+  if (!fs.existsSync(targetDir)) {
+    fs.mkdirSync(targetDir, { recursive: true });
+    console.log('✓ Created atris/ folder');
+  } else {
+    console.log('✓ atris/ folder already exists');
+  }
+
+  if (!fs.existsSync(agentTeamDir)) {
+    fs.mkdirSync(agentTeamDir, { recursive: true });
+    console.log('✓ Created atris/agent_team/ folder');
+  }
+
+  const gettingStartedFile = path.join(targetDir, 'GETTING_STARTED.md');
+  const personaFile = path.join(targetDir, 'PERSONA.md');
+  const mapFile = path.join(targetDir, 'MAP.md');
+  const taskContextsFile = path.join(targetDir, 'TASK_CONTEXTS.md');
+  const navigatorFile = path.join(agentTeamDir, 'navigator.md');
+  const executorFile = path.join(agentTeamDir, 'executor.md');
+  const validatorFile = path.join(agentTeamDir, 'validator.md');
+  const launcherFile = path.join(agentTeamDir, 'launcher.md');
+
+  const gettingStartedSource = path.join(__dirname, '..', 'GETTING_STARTED.md');
+  const personaSource = path.join(__dirname, '..', 'PERSONA.md');
+
+  if (!fs.existsSync(gettingStartedFile) && fs.existsSync(gettingStartedSource)) {
+    fs.copyFileSync(gettingStartedSource, gettingStartedFile);
+    console.log('✓ Created GETTING_STARTED.md');
+  }
+
+  if (!fs.existsSync(personaFile) && fs.existsSync(personaSource)) {
+    fs.copyFileSync(personaSource, personaFile);
+    console.log('✓ Created PERSONA.md');
+  }
+
+  if (!fs.existsSync(mapFile)) {
+    fs.writeFileSync(mapFile, '# MAP.md\n\n> Generated by your AI agent after reading atris.md\n\nRun your AI agent with atris.md to populate this file.\n');
+    console.log('✓ Created MAP.md placeholder');
+  }
+
+  if (!fs.existsSync(taskContextsFile)) {
+    fs.writeFileSync(taskContextsFile, '# TASK_CONTEXTS.md\n\n> Generated by your AI agent after reading atris.md\n\nRun your AI agent with atris.md to populate this file.\n');
+    console.log('✓ Created TASK_CONTEXTS.md placeholder');
+  }
+
+  const navigatorSource = path.join(__dirname, '..', 'atris', 'agent_team', 'navigator.md');
+  const executorSource = path.join(__dirname, '..', 'atris', 'agent_team', 'executor.md');
+  const validatorSource = path.join(__dirname, '..', 'atris', 'agent_team', 'validator.md');
+  const launcherSource = path.join(__dirname, '..', 'atris', 'agent_team', 'launcher.md');
+
+  if (!fs.existsSync(navigatorFile) && fs.existsSync(navigatorSource)) {
+    fs.copyFileSync(navigatorSource, navigatorFile);
+    console.log('✓ Created agent_team/navigator.md');
+  }
+
+  if (!fs.existsSync(executorFile) && fs.existsSync(executorSource)) {
+    fs.copyFileSync(executorSource, executorFile);
+    console.log('✓ Created agent_team/executor.md');
+  }
+
+  if (!fs.existsSync(validatorFile) && fs.existsSync(validatorSource)) {
+    fs.copyFileSync(validatorSource, validatorFile);
+    console.log('✓ Created agent_team/validator.md');
+  }
+
+  if (!fs.existsSync(launcherFile) && fs.existsSync(launcherSource)) {
+    fs.copyFileSync(launcherSource, launcherFile);
+    console.log('✓ Created agent_team/launcher.md');
+  }
+
+  if (fs.existsSync(sourceFile)) {
+    fs.copyFileSync(sourceFile, targetFile);
+    console.log('✓ Copied atris.md to atris/ folder');
+    console.log('\n✨ ATRIS initialized! Full structure created:');
+    console.log('   atris/');
+    console.log('   ├── GETTING_STARTED.md (read this first!)');
+    console.log('   ├── PERSONA.md (agent personality)');
+    console.log('   ├── atris.md (AI agent instructions)');
+    console.log('   ├── MAP.md (placeholder)');
+    console.log('   ├── TASK_CONTEXTS.md (placeholder)');
+    console.log('   └── agent_team/');
+    console.log('       ├── navigator.md (placeholder)');
+    console.log('       ├── executor.md (placeholder)');
+    console.log('       ├── validator.md (placeholder)');
+    console.log('       └── launcher.md (placeholder)');
+    console.log('\nNext steps:');
+    console.log('1. Read atris/GETTING_STARTED.md for the full guide');
+    console.log('2. Open atris/atris.md and paste it to your AI agent');
+    console.log('3. Your agent will populate all placeholder files in ~10 mins');
+  } else {
+    console.error('✗ Error: atris.md not found in package');
+    process.exit(1);
+  }
+}
+
+module.exports = { initAtris };

package/commands/log-sync.js

@@ -0,0 +1,261 @@
+const fs = require('fs');
+const path = require('path');
+const { getLogPath, ensureLogDirectory, createLogFile } = require('../lib/file-ops');
+const { parseJournalSections, mergeSections, reconstructJournal, showLogDiff } = require('../lib/journal');
+const { computeContentHash, isSameTimestamp } = require('../lib/journal');
+const { loadConfig, loadLogSyncState, saveLogSyncState } = require('../utils/config');
+const { ensureValidCredentials } = require('../utils/auth');
+const { apiRequestJson } = require('../utils/api');
+const { promptUser } = require('../utils/auth');
+
+async function logSyncAtris() {
+  const targetDir = path.join(process.cwd(), 'atris');
+
+  if (!fs.existsSync(targetDir)) {
+    throw new Error('atris/ folder not found. Run "atris init" first.');
+  }
+
+  let dateArg = process.argv[4];
+  if (dateArg && dateArg.startsWith('--date=')) {
+    dateArg = dateArg.split('=')[1];
+  }
+
+  let { logsDir, yearDir, logFile, dateFormatted } = getLogPath(dateArg);
+  if (Number.isNaN(new Date(dateFormatted).getTime())) {
+    throw new Error(`Invalid date provided: ${dateArg}`);
+  }
+
+  if (!fs.existsSync(logsDir)) {
+    fs.mkdirSync(logsDir, { recursive: true });
+  }
+  if (!fs.existsSync(yearDir)) {
+    fs.mkdirSync(yearDir, { recursive: true });
+  }
+  if (!fs.existsSync(logFile)) {
+    createLogFile(logFile, dateFormatted);
+    console.log(`Created local log template for ${dateFormatted}. Fill it in before syncing.`);
+  }
+
+  const localContent = fs.readFileSync(logFile, 'utf8');
+  const localHash = computeContentHash(localContent);
+
+  const config = loadConfig();
+  if (!config.agent_id) {
+    throw new Error('No agent selected. Run "atris agent" first.');
+  }
+
+  const ensured = await ensureValidCredentials(apiRequestJson);
+  if (ensured.error) {
+    if (ensured.error === 'not_logged_in') {
+      throw new Error('Not logged in. Run "atris login" first.');
+    }
+    if (ensured.detail && ensured.detail.toLowerCase().includes('enotfound')) {
+      throw new Error('Unable to reach Atris API. Check your network connection.');
+    }
+    throw new Error(ensured.detail || ensured.error || 'Authentication failed');
+  }
+
+  const credentials = ensured.credentials;
+  const agentId = config.agent_id;
+  const agentLabel = config.agent_name || agentId;
+
+  console.log(`🔄 Syncing log for ${dateFormatted} with agent "${agentLabel}"`);
+
+  const syncState = loadLogSyncState();
+  const knownRemoteUpdate = syncState[dateFormatted]?.updated_at || null;
+  const knownRemoteHash = syncState[dateFormatted]?.hash || null;
+
+  let remoteExists = false;
+  let remoteUpdatedAt = null;
+  let remoteContent = null;
+  let remoteHash = null;
+  const existing = await apiRequestJson(`/agents/${agentId}/journal/${dateFormatted}`, {
+    method: 'GET',
+    token: credentials.token,
+  });
+
+  if (existing.ok) {
+    remoteExists = true;
+    remoteUpdatedAt = existing.data?.updated_at || existing.data?.created_at || null;
+    remoteContent = typeof existing.data?.content === 'string' ? existing.data.content : null;
+    remoteHash = remoteContent ? computeContentHash(remoteContent) : null;
+
+    if (remoteUpdatedAt) {
+      const localStats = fs.statSync(logFile);
+      const localModified = localStats.mtime.toISOString();
+      const remoteTime = new Date(remoteUpdatedAt).getTime();
+      const localTime = new Date(localModified).getTime();
+
+      const remoteMatchesKnown = (knownRemoteUpdate && isSameTimestamp(remoteUpdatedAt, knownRemoteUpdate))
+        || (remoteHash && knownRemoteHash && remoteHash === knownRemoteHash);
+
+      if (remoteTime > localTime && !remoteMatchesKnown) {
+        const normalizedRemote = remoteContent ? remoteContent.replace(/\r\n/g, '\n') : null;
+        const normalizedLocal = localContent.replace(/\r\n/g, '\n');
+        if (normalizedRemote !== null && normalizedRemote.trim() === normalizedLocal.trim()) {
+          const remoteDate = new Date(remoteUpdatedAt);
+          if (!Number.isNaN(remoteDate.getTime())) {
+            fs.utimesSync(logFile, remoteDate, remoteDate);
+            const state = loadLogSyncState();
+            state[dateFormatted] = {
+              updated_at: remoteUpdatedAt,
+              hash: remoteHash || knownRemoteHash || computeContentHash(remoteContent || ''),
+            };
+            saveLogSyncState(state);
+          }
+          console.log('✓ Already synced (timestamps aligned with web)');
+          return;
+        }
+
+        try {
+          const localSections = parseJournalSections(normalizedLocal);
+          const remoteSections = parseJournalSections(normalizedRemote || '');
+          const { merged, conflicts } = mergeSections(localSections, remoteSections, knownRemoteHash);
+
+          if (conflicts.length === 0) {
+            const mergedContent = reconstructJournal(merged);
+            fs.writeFileSync(logFile, mergedContent, 'utf8');
+            console.log('✓ Auto-merged web and local changes');
+            console.log(`   Merged sections: ${Object.keys(merged).filter(k => k !== '__header__').join(', ')}`);
+            localContent = mergedContent;
+          } else {
+            console.log('⚠️  Conflicting changes in same section(s)');
+            console.log(`   Conflicts: ${conflicts.join(', ')}`);
+            console.log(`   Remote updated: ${remoteUpdatedAt}`);
+            console.log(`   Local modified: ${localModified}`);
+            console.log('   Type "y" to replace local with web version, or "n" to keep local changes.');
+            console.log('');
+
+            if (typeof remoteContent === 'string') {
+              showLogDiff(logFile, remoteContent);
+            }
+
+            const answer = await promptUser('Overwrite local with web version? (y/n): ');
+
+            if (answer && answer.toLowerCase() === 'y') {
+              const pulledContent = existing.data?.content || '';
+              fs.writeFileSync(logFile, pulledContent, 'utf8');
+              remoteHash = computeContentHash(pulledContent);
+              console.log('✓ Local journal updated from web');
+              console.log(`🗒️  File: ${path.relative(process.cwd(), logFile)}`);
+              if (remoteUpdatedAt) {
+                const remoteDate = new Date(remoteUpdatedAt);
+                if (!Number.isNaN(remoteDate.getTime())) {
+                  fs.utimesSync(logFile, remoteDate, remoteDate);
+                }
+                const state = loadLogSyncState();
+                state[dateFormatted] = {
+                  updated_at: remoteUpdatedAt,
+                  hash: remoteHash || computeContentHash(pulledContent),
+                };
+                saveLogSyncState(state);
+              }
+              return;
+            } else {
+              console.log('⏩ Keeping local version, will push to web');
+            }
+          }
+        } catch (parseError) {
+          console.log('⚠️  Web version is newer than local version');
+          console.log(`   Remote updated: ${remoteUpdatedAt}`);
+          console.log(`   Local modified: ${localModified}`);
+          console.log('   Type "y" to replace your local file with the web version, or "n" to keep local changes and push them to the web.');
+          console.log('');
+
+          if (typeof remoteContent === 'string') {
+            showLogDiff(logFile, remoteContent);
+          }
+
+          const answer = await promptUser('Overwrite local with web version? (y/n): ');
+
+          if (answer && answer.toLowerCase() === 'y') {
+            const pulledContent = existing.data?.content || '';
+            fs.writeFileSync(logFile, pulledContent, 'utf8');
+            remoteHash = computeContentHash(pulledContent);
+            console.log('✓ Local journal updated from web');
+            console.log(`🗒️  File: ${path.relative(process.cwd(), logFile)}`);
+            if (remoteUpdatedAt) {
+              const remoteDate = new Date(remoteUpdatedAt);
+              if (!Number.isNaN(remoteDate.getTime())) {
+                fs.utimesSync(logFile, remoteDate, remoteDate);
+              }
+              const state = loadLogSyncState();
+              state[dateFormatted] = {
+                updated_at: remoteUpdatedAt,
+                hash: remoteHash || computeContentHash(pulledContent),
+              };
+              saveLogSyncState(state);
+            }
+            return;
+          } else {
+            console.log('⏩ Keeping local version, will push to web');
+          }
+        }
+      } else if (remoteTime > localTime && remoteMatchesKnown) {
+        console.log('⚠️  Web timestamp ahead due to clock skew (matches last sync); pushing local changes.');
+      } else if (remoteTime === localTime) {
+        console.log('✓ Already synced (local and web are identical)');
+        if (remoteUpdatedAt) {
+          const state = loadLogSyncState();
+          state[dateFormatted] = {
+            updated_at: remoteUpdatedAt,
+            hash: remoteHash || knownRemoteHash || computeContentHash(remoteContent || ''),
+          };
+          saveLogSyncState(state);
+        }
+        return;
+      }
+    }
+  } else if (!existing.status) {
+    throw new Error('Unable to reach Atris API. Check your network connection.');
+  } else if (existing.status && existing.status !== 404) {
+    throw new Error(existing.error || 'Failed to check existing journal entry');
+  }
+
+  const payload = {
+    content: localContent,
+    metadata: {
+      source: 'cli',
+      local_path: `logs/${dateFormatted}.md`,
+    },
+  };
+
+  const result = await apiRequestJson(`/agents/${agentId}/journal/${dateFormatted}`, {
+    method: 'PUT',
+    token: credentials.token,
+    body: payload,
+  });
+
+  if (!result.ok) {
+    if (!result.status) {
+      throw new Error('Unable to reach Atris API. Check your network connection.');
+    }
+    throw new Error(result.error || 'Failed to sync journal entry');
+  }
+
+  const data = result.data || {};
+  const updatedAt = data.updated_at || new Date().toISOString();
+
+  if (remoteExists) {
+    console.log(`✓ Updated journal entry (previous update: ${remoteUpdatedAt || 'unknown'})`);
+  } else {
+    console.log('✓ Created journal entry in Atris');
+  }
+
+  console.log(`🗒️  Local file: ${path.relative(process.cwd(), logFile)}`);
+  console.log(`🕒 Updated at: ${updatedAt}`);
+  const updatedDate = new Date(updatedAt);
+  if (!Number.isNaN(updatedDate.getTime())) {
+    fs.utimesSync(logFile, updatedDate, updatedDate);
+  }
+  const finalContent = fs.readFileSync(logFile, 'utf8');
+  const finalHash = computeContentHash(finalContent);
+  const finalState = loadLogSyncState();
+  finalState[dateFormatted] = {
+    updated_at: updatedAt,
+    hash: finalHash,
+  };
+  saveLogSyncState(finalState);
+}
+
+module.exports = { logSyncAtris };