@mndrk/agx 1.4.2 → 1.4.4

package/README.md

@@ -18,8 +18,8 @@ agx -p "what does this function do?"
 # With persistent memory (auto-detected)
 agx claude -p "continue working on the todo app"
 
-# Auto-create task (for agents, non-interactive)
-agx claude --auto-task -p "Build a todo app with React"
+# Autonomous mode - creates task and works until done
+agx claude --autonomous -p "Build a todo app with React"
 ```
 
 ## Memory Integration
@@ -74,10 +74,9 @@ Agents control state via markers in their output:
 --interactive, -i      Force interactive mode
 --mem                  Enable mem integration (auto-detected)
 --no-mem               Disable mem integration
---auto-task            Auto-create task from prompt
+--autonomous, -a       Create task and run autonomously (starts daemon)
 --task <name>          Specific task name
 --criteria <text>      Success criterion (repeatable)
---daemon               Loop on [continue] marker
 ```
 
 ## Claude Code Plugin
@@ -100,8 +99,32 @@ agx config             # Configuration menu
 agx status             # Show current config
 agx skill              # View LLM skill
 agx skill install      # Install skill to Claude/Gemini
+
+# Daemon management
+agx daemon start       # Start background daemon
+agx daemon stop        # Stop daemon
+agx daemon status      # Check if running
+agx daemon logs        # Show recent logs
 ```
 
+## Autonomous Mode
+
+Start a task that runs autonomously until complete:
+
+```bash
+agx claude --autonomous -p "Build a React todo app with auth"
+# ✓ Created task: build-react-todo
+# ✓ Mapped: ~/Projects/app → task/build-react-todo
+# ✓ Daemon started (pid 12345)
+# ✓ Autonomous mode: daemon will continue work every 15m
+```
+
+The daemon:
+- Runs in background (survives terminal close)
+- Wakes every 15 minutes
+- Continues work on active tasks
+- Stops when task is `[done]` or `[blocked]`
+
 ## Loop Control
 
 The agent controls execution flow via markers:

package/commands/daemon.md

@@ -0,0 +1,36 @@
+# /agx:daemon - Manage Background Daemon
+
+Control the agx daemon that runs autonomous tasks.
+
+## Usage
+```
+/agx:daemon <action>
+```
+
+## Actions
+- `start` - Start the daemon
+- `stop` - Stop the daemon
+- `status` - Check if running
+- `logs` - Show recent logs
+
+## Implementation
+
+```bash
+# Check status
+agx daemon status
+
+# Start if needed
+agx daemon start
+
+# View logs
+agx daemon logs
+
+# Stop when done
+agx daemon stop
+```
+
+The daemon:
+- Runs in background (survives terminal close)
+- Wakes every 15 minutes
+- Continues work on active tasks
+- Stops tasks when they output [done] or [blocked]

package/commands/spawn.md

@@ -1,6 +1,6 @@
-# /agx:spawn - Spawn Background Agent
+# /agx:spawn - Start Autonomous Task
 
-Spawn a background agent task with automatic wake schedule.
+Spawn an autonomous agent task that runs until complete.
 
 ## Usage
 ```
@@ -15,17 +15,17 @@ Spawn a background agent task with automatic wake schedule.
 First, ensure you're in the correct project directory, then:
 
 ```bash
-agx claude --auto-task -p "$ARGUMENTS"
+agx claude --autonomous -p "$ARGUMENTS"
 ```
 
 This will:
 1. Create a mem task branch
-2. Set wake schedule (every 15m)
-3. Start the agent working
+2. Start the agx daemon (if not running)
+3. Begin working on the task
+4. Daemon wakes every 15m to continue until [done]
 
-After spawning, install the wake cron:
+Check status with:
 ```bash
-(crontab -l 2>/dev/null; mem cron export) | crontab -
+agx daemon status
+mem status
 ```
-
-Report the task name and confirm wake schedule is set.

package/index.js

@@ -36,7 +36,7 @@ agx auto-detects \`~/.mem\` and loads context:
 agx claude -p "continue working"
 
 # Auto-create task (non-interactive, for agents)
-agx claude --auto-task -p "Build todo app"
+agx claude --autonomous -p "Build todo app"
 
 # Explicit task with criteria
 agx claude --task todo-app \\
@@ -79,7 +79,7 @@ Use these in agent output to save state:
 | --yolo, -y | Skip permission prompts |
 | --mem | Enable mem (auto-detected) |
 | --no-mem | Disable mem |
-| --auto-task | Auto-create task from prompt |
+| --autonomous, -a | Create task and run autonomously until done |
 | --task NAME | Specific task name |
 | --criteria "..." | Success criterion (repeatable) |
 | --daemon | Loop on [continue] marker |
@@ -148,7 +148,7 @@ function findMemDir(startDir = process.cwd()) {
   while (dir !== path.dirname(dir)) {
     const memDir = path.join(dir, '.mem');
     if (fs.existsSync(memDir) && fs.existsSync(path.join(memDir, '.git'))) {
-      return memDir;
+      return { memDir, taskBranch: null, projectDir: dir, isLocal: true };
     }
     dir = path.dirname(dir);
   }
@@ -162,14 +162,14 @@ function findMemDir(startDir = process.cwd()) {
         const index = JSON.parse(fs.readFileSync(indexFile, 'utf8'));
         // Exact match
         if (index[startDir]) {
-          return globalMem;
+          return { memDir: globalMem, taskBranch: index[startDir], projectDir: startDir, isLocal: false };
         }
         // Check parent directories (for monorepo/subdirectory usage)
         let checkDir = startDir;
         while (checkDir !== path.dirname(checkDir)) {
           checkDir = path.dirname(checkDir);
           if (index[checkDir]) {
-            return globalMem;
+            return { memDir: globalMem, taskBranch: index[checkDir], projectDir: checkDir, isLocal: false };
           }
         }
       } catch {}
@@ -179,11 +179,22 @@ function findMemDir(startDir = process.cwd()) {
   return null;
 }
 
-// Load mem context
-function loadMemContext(memDir) {
+// Load mem context for a specific task
+function loadMemContext(memInfo) {
   try {
+    // If we know the task branch, switch to it first to ensure correct context
+    if (memInfo.taskBranch && !memInfo.isLocal) {
+      try {
+        execSync(`git checkout ${memInfo.taskBranch}`, { 
+          cwd: memInfo.memDir, 
+          stdio: ['pipe', 'pipe', 'pipe'] 
+        });
+      } catch {}
+    }
+    
+    // Run mem context from the project directory
     const result = execSync('mem context', { 
-      cwd: path.dirname(memDir),
+      cwd: memInfo.projectDir,
       encoding: 'utf8',
       stdio: ['pipe', 'pipe', 'pipe']
     });
@@ -225,8 +236,9 @@ function parseMemMarkers(output) {
 }
 
 // Apply mem markers - returns control signals
-function applyMemMarkers(markers, memDir) {
-  const workDir = path.dirname(memDir);
+function applyMemMarkers(markers, memInfo) {
+  // Use project directory for commands (not parent of ~/.mem)
+  const workDir = memInfo.projectDir || path.dirname(memInfo.memDir || memInfo);
   const result = {
     approvals: [],
     shouldContinue: false,
@@ -300,8 +312,8 @@ function applyMemMarkers(markers, memDir) {
 }
 
 // Create subtasks from split markers
-function createSubtasks(splits, memDir) {
-  const workDir = path.dirname(memDir);
+function createSubtasks(splits, memInfo) {
+  const workDir = memInfo.projectDir || path.dirname(memInfo.memDir || memInfo);
   
   for (const split of splits) {
     try {
@@ -317,6 +329,200 @@ function createSubtasks(splits, memDir) {
   }
 }
 
+// ==================== DAEMON ====================
+
+const DAEMON_PID_FILE = path.join(process.env.HOME || process.env.USERPROFILE, '.agx', 'daemon.pid');
+const DAEMON_LOG_FILE = path.join(process.env.HOME || process.env.USERPROFILE, '.agx', 'daemon.log');
+const DAEMON_STATE_FILE = path.join(process.env.HOME || process.env.USERPROFILE, '.agx', 'daemon-state.json');
+
+function isDaemonRunning() {
+  try {
+    if (!fs.existsSync(DAEMON_PID_FILE)) return false;
+    const pid = parseInt(fs.readFileSync(DAEMON_PID_FILE, 'utf8').trim());
+    process.kill(pid, 0); // Check if process exists
+    return pid;
+  } catch {
+    return false;
+  }
+}
+
+function startDaemon() {
+  const existingPid = isDaemonRunning();
+  if (existingPid) {
+    console.log(`${c.dim}Daemon already running (pid ${existingPid})${c.reset}`);
+    return existingPid;
+  }
+
+  // Ensure .agx directory exists
+  const agxDir = path.dirname(DAEMON_PID_FILE);
+  if (!fs.existsSync(agxDir)) {
+    fs.mkdirSync(agxDir, { recursive: true });
+  }
+
+  // Spawn daemon process
+  const agxPath = process.argv[1]; // Current script path
+  const daemon = spawn(process.execPath, [agxPath, 'daemon', '--run'], {
+    detached: true,
+    stdio: ['ignore', 
+      fs.openSync(DAEMON_LOG_FILE, 'a'), 
+      fs.openSync(DAEMON_LOG_FILE, 'a')
+    ],
+    env: { ...process.env, AGX_DAEMON: '1' }
+  });
+
+  daemon.unref();
+  fs.writeFileSync(DAEMON_PID_FILE, String(daemon.pid));
+  
+  console.log(`${c.green}✓${c.reset} Daemon started (pid ${daemon.pid})`);
+  console.log(`${c.dim}  Logs: ${DAEMON_LOG_FILE}${c.reset}`);
+  
+  return daemon.pid;
+}
+
+function stopDaemon() {
+  const pid = isDaemonRunning();
+  if (!pid) {
+    console.log(`${c.yellow}Daemon not running${c.reset}`);
+    return false;
+  }
+  
+  try {
+    process.kill(pid, 'SIGTERM');
+    fs.unlinkSync(DAEMON_PID_FILE);
+    console.log(`${c.green}✓${c.reset} Daemon stopped (pid ${pid})`);
+    return true;
+  } catch (err) {
+    console.error(`${c.red}Failed to stop daemon:${c.reset} ${err.message}`);
+    return false;
+  }
+}
+
+// Parse wake pattern to milliseconds (e.g., "every 15m" → 900000)
+function parseWakeInterval(pattern) {
+  if (!pattern) return null;
+  
+  const match = pattern.match(/every\s+(\d+)\s*(m|min|h|hr|hour)/i);
+  if (match) {
+    const value = parseInt(match[1]);
+    const unit = match[2].toLowerCase();
+    if (unit.startsWith('h')) return value * 60 * 60 * 1000;
+    return value * 60 * 1000; // minutes
+  }
+  return null;
+}
+
+async function runDaemon() {
+  console.log(`[${new Date().toISOString()}] Daemon starting...`);
+  
+  const DEFAULT_WAKE_INTERVAL = 15 * 60 * 1000; // 15 minutes fallback
+  const TICK_INTERVAL = 60 * 1000; // Check every 1 minute
+  const memDir = path.join(process.env.HOME || process.env.USERPROFILE, '.mem');
+  
+  // Load/save daemon state (last run times per task)
+  function loadState() {
+    try {
+      if (fs.existsSync(DAEMON_STATE_FILE)) {
+        return JSON.parse(fs.readFileSync(DAEMON_STATE_FILE, 'utf8'));
+      }
+    } catch {}
+    return { lastRun: {} };
+  }
+  
+  function saveState(state) {
+    const dir = path.dirname(DAEMON_STATE_FILE);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(DAEMON_STATE_FILE, JSON.stringify(state, null, 2));
+  }
+  
+  // Get wake interval for a specific task
+  function getTaskWakeInterval(projectDir) {
+    try {
+      const wake = execSync('mem wake', { cwd: projectDir, encoding: 'utf8' });
+      const wakeMatch = wake.match(/Wake:\s*(.+)/);
+      if (wakeMatch) {
+        const interval = parseWakeInterval(wakeMatch[1]);
+        if (interval) return interval;
+      }
+    } catch {}
+    return DEFAULT_WAKE_INTERVAL;
+  }
+  
+  const tick = async () => {
+    const now = Date.now();
+    const state = loadState();
+    
+    // Get task list from mem index
+    const indexFile = path.join(memDir, 'index.json');
+    if (!fs.existsSync(indexFile)) return;
+    
+    const index = JSON.parse(fs.readFileSync(indexFile, 'utf8'));
+    let ranAny = false;
+    
+    for (const [projectDir, taskBranch] of Object.entries(index)) {
+      if (!fs.existsSync(projectDir)) continue;
+      
+      try {
+        // Check if task is due based on its wake interval
+        const wakeInterval = getTaskWakeInterval(projectDir);
+        const lastRun = state.lastRun[taskBranch] || 0;
+        const elapsed = now - lastRun;
+        
+        if (elapsed < wakeInterval) {
+          continue; // Not due yet
+        }
+        
+        // Use mem to switch and check status
+        execSync(`mem switch ${taskBranch.replace('task/', '')}`, { cwd: projectDir, stdio: 'ignore' });
+        const status = execSync('mem status', { cwd: projectDir, encoding: 'utf8' });
+        
+        // Check if task is active (not done/blocked)
+        if (status.includes('status: done') || status.includes('status: blocked')) {
+          continue; // Skip inactive tasks
+        }
+        
+        console.log(`[${new Date().toISOString()}] Running task: ${taskBranch} (due after ${Math.round(wakeInterval/60000)}m)`);
+        ranAny = true;
+        
+        // Update last run time before executing (in case it takes a while)
+        state.lastRun[taskBranch] = now;
+        saveState(state);
+        
+        // Run agx continue
+        try {
+          execSync(`agx claude -y -p "continue"`, { 
+            cwd: projectDir, 
+            stdio: 'inherit',
+            timeout: 10 * 60 * 1000 // 10 min timeout
+          });
+        } catch (err) {
+          console.log(`[${new Date().toISOString()}] Task ${taskBranch} error: ${err.message}`);
+        }
+        
+      } catch (err) {
+        console.log(`[${new Date().toISOString()}] Error checking ${taskBranch}: ${err.message}`);
+      }
+    }
+    
+    if (!ranAny) {
+      // Only log periodically to avoid spam
+      const lastLog = state.lastLog || 0;
+      if (now - lastLog > 5 * 60 * 1000) { // Every 5 min
+        console.log(`[${new Date().toISOString()}] Daemon tick - no tasks due`);
+        state.lastLog = now;
+        saveState(state);
+      }
+    }
+  };
+  
+  // Initial tick
+  await tick();
+  
+  // Check every minute, but only run tasks when their interval is due
+  setInterval(tick, TICK_INTERVAL);
+  
+  console.log(`[${new Date().toISOString()}] Daemon running, checking every ${TICK_INTERVAL / 1000}s`);
+}
+
 // Handle approval prompts
 async function handleApprovals(approvals) {
   if (approvals.length === 0) return true;
@@ -915,6 +1121,48 @@ async function checkOnboarding() {
     return true;
   }
 
+  // Daemon commands
+  if (cmd === 'daemon') {
+    const subcmd = args[1];
+    if (subcmd === 'start') {
+      startDaemon();
+      process.exit(0);
+    } else if (subcmd === 'stop') {
+      stopDaemon();
+      process.exit(0);
+    } else if (subcmd === 'status') {
+      const pid = isDaemonRunning();
+      if (pid) {
+        console.log(`${c.green}Daemon running${c.reset} (pid ${pid})`);
+        console.log(`${c.dim}Logs: ${DAEMON_LOG_FILE}${c.reset}`);
+      } else {
+        console.log(`${c.yellow}Daemon not running${c.reset}`);
+      }
+      process.exit(0);
+    } else if (subcmd === 'logs') {
+      if (fs.existsSync(DAEMON_LOG_FILE)) {
+        const logs = fs.readFileSync(DAEMON_LOG_FILE, 'utf8');
+        console.log(logs.split('\n').slice(-50).join('\n'));
+      } else {
+        console.log(`${c.dim}No logs yet${c.reset}`);
+      }
+      process.exit(0);
+    } else if (subcmd === '--run') {
+      // Internal: actually run the daemon loop
+      await runDaemon();
+      return true; // Never exits
+    } else {
+      console.log(`${c.bold}agx daemon${c.reset} - Background task runner\n`);
+      console.log(`Commands:`);
+      console.log(`  agx daemon start   Start the daemon`);
+      console.log(`  agx daemon stop    Stop the daemon`);
+      console.log(`  agx daemon status  Check if running`);
+      console.log(`  agx daemon logs    Show recent logs`);
+      process.exit(0);
+    }
+    return true;
+  }
+
   // Login command
   if (cmd === 'login') {
     const provider = args[1];
@@ -1114,7 +1362,7 @@ const options = {
   mcp: null,
   mem: false,
   memDir: null,
-  autoTask: false,
+  autonomous: false,
   taskName: null,
   criteria: [],
   daemon: false,
@@ -1175,9 +1423,12 @@ for (let i = 0; i < processedArgs.length; i++) {
     case '--no-mem':
       options.mem = false;
       break;
-    case '--auto-task':
-      options.autoTask = true;
+    case '--autonomous':
+    case '--auto':
+    case '-a':
+      options.autonomous = true;
       options.mem = true;
+      options.yolo = true; // Autonomous = unattended, skip prompts
       break;
     case '--task':
       if (nextArg && !nextArg.startsWith('-')) {
@@ -1282,14 +1533,15 @@ translatedArgs.push(...rawArgs);
 // ==================== MEM INTEGRATION ====================
 
 // Auto-detect mem if .mem exists (unless --no-mem)
-let memDir = options.mem !== false ? findMemDir() : null;
-if (memDir && options.mem !== false) {
+let memInfo = options.mem !== false ? findMemDir() : null;
+if (memInfo && options.mem !== false) {
   options.mem = true;
-  options.memDir = memDir;
+  options.memInfo = memInfo;
+  options.memDir = memInfo.memDir; // For backwards compat
 }
 
-// Auto-create task if --auto-task or --task specified but no mem found
-if ((options.autoTask || options.taskName) && !options.memDir && finalPrompt) {
+// Auto-create task if --autonomous or --task specified but no mem found
+if ((options.autonomous || options.taskName) && !options.memInfo && finalPrompt) {
   const taskName = options.taskName || finalPrompt
     .toLowerCase()
     .replace(/[^a-z0-9\s]/g, '')
@@ -1345,33 +1597,32 @@ if ((options.autoTask || options.taskName) && !options.memDir && finalPrompt) {
     fs.writeFileSync(indexFile, JSON.stringify(index, null, 2));
     
     options.memDir = centralMem;
+    options.memInfo = { memDir: centralMem, taskBranch: branch, projectDir: process.cwd(), isLocal: false };
     console.log(`${c.green}✓${c.reset} Created task: ${c.bold}${taskName}${c.reset}`);
     console.log(`${c.green}✓${c.reset} Mapped: ${c.dim}${process.cwd()} → ${branch}${c.reset}`);
     
-    // Auto-set wake schedule for new tasks with proper command
-    // Detect agx path dynamically for cron (no PATH in cron env)
+    // Auto-set wake schedule 
     try {
-      const projectDir = process.cwd();
-      let agxPath = 'agx';
-      try {
-        agxPath = execSync('which agx', { encoding: 'utf8' }).trim();
-      } catch {}
-      const wakeCmd = `cd ${projectDir} && ${agxPath} claude -y -p "continue"`;
-      execSync(`mem wake "every 15m" --run "${wakeCmd}"`, { cwd: process.cwd(), stdio: 'ignore' });
-      console.log(`${c.green}✓${c.reset} Wake: ${c.dim}every 15m (until done)${c.reset}`);
-      console.log(`${c.dim}       Run: agx claude -y -p "continue"${c.reset}\n`);
+      execSync(`mem wake "every 15m"`, { cwd: process.cwd(), stdio: 'ignore' });
     } catch {}
     
+    // Start daemon for autonomous mode
+    if (options.autonomous) {
+      startDaemon();
+      console.log(`${c.green}✓${c.reset} Autonomous mode: daemon will continue work every 15m\n`);
+    }
+    
   } catch (err) {
     console.error(`${c.yellow}Warning: Could not create task:${c.reset} ${err.message}`);
   }
 }
 
 // Prepend mem context to prompt if mem is enabled
-if (options.mem && options.memDir && finalPrompt) {
-  const context = loadMemContext(options.memDir);
+if (options.mem && options.memInfo && finalPrompt) {
+  const context = loadMemContext(options.memInfo);
   if (context) {
-    console.log(`${c.dim}[mem] Loaded context from ${options.memDir}${c.reset}\n`);
+    const taskInfo = options.memInfo.taskBranch || 'local';
+    console.log(`${c.dim}[mem] Loaded context: ${taskInfo} (${options.memInfo.projectDir})${c.reset}\n`);
     
     // Prepend context to prompt with full marker documentation
     const augmentedPrompt = `## Current Context (from mem)\n\n${context}\n\n## Task\n\n${finalPrompt}\n\n## Instructions\n\nYou are continuing work on this task. Review the context above, then continue where you left off.\n\n## Output Markers\n\nUse these markers to save state (will be parsed automatically):\n\n- [checkpoint: message] - save progress point\n- [learn: insight] - record a learning  \n- [next: step] - set what to work on next\n- [criteria: N] - mark criterion #N complete\n- [split: name "goal"] - break into subtask\n\nStopping markers (only use when needed):\n- [done] - task complete (all criteria met)\n- [blocked: reason] - need human help, cannot proceed\n- [approve: question] - need human approval before continuing\n\nThe default is to keep working. You will wake again in 15 minutes to continue.`;
@@ -1407,11 +1658,11 @@ if (options.mem && options.memDir) {
     
     if (markers.length > 0) {
       console.log(`\n${c.dim}[mem] Processing markers...${c.reset}`);
-      const result = applyMemMarkers(markers, options.memDir);
+      const result = applyMemMarkers(markers, options.memInfo || { memDir: options.memDir, projectDir: process.cwd() });
       
       // Create subtasks if any
       if (result.splits.length > 0) {
-        createSubtasks(result.splits, options.memDir);
+        createSubtasks(result.splits, options.memInfo || { memDir: options.memDir, projectDir: process.cwd() });
       }
       
       // Handle approvals

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mndrk/agx",
-  "version": "1.4.2",
+  "version": "1.4.4",
   "description": "Unified AI Agent Wrapper for Gemini, Claude, and Ollama",
   "main": "index.js",
   "bin": {

package/skills/agx/SKILL.md

@@ -1,13 +1,13 @@
 # agx - Unified AI Agent Wrapper
 
-Use `agx` to run AI agents (Claude Code, Gemini, Ollama) with persistent memory integration. Spawn background tasks that wake automatically and continue working.
+Use `agx` to run AI agents (Claude Code, Gemini, Ollama) with persistent memory integration. Spawn autonomous tasks that work in the background until complete.
 
 ## When to Use
 
-- **Spawning background agents** for long-running tasks
-- **Auto-task creation** with wake schedules
+- **Autonomous agents** for long-running tasks
+- **Background work** that continues without supervision
 - **Running different AI providers** with unified interface
-- **Autonomous work loops** that continue until done
+- **Persistent memory** across sessions
 
 ## Basic Usage
 
@@ -17,41 +17,43 @@ agx gemini -p "prompt"              # Run Gemini
 agx ollama -p "prompt"              # Run Ollama (local)
 ```
 
-## Auto-Task Mode (Recommended)
+## Autonomous Mode (Recommended)
 
-Create a task with automatic wake schedule:
+Start a task that runs autonomously until complete:
 
 ```bash
 cd ~/Projects/my-app
-agx claude --auto-task -p "Build a React todo app with auth"
+agx claude --autonomous -p "Build a React todo app with auth"
 # ✓ Created task: build-react-todo
 # ✓ Mapped: ~/Projects/my-app → task/build-react-todo
-# ✓ Wake: every 15m (until done)
+# ✓ Daemon started (pid 12345)
+# ✓ Autonomous mode: daemon will continue work every 15m
 ```
 
 This:
 1. Creates a mem task branch
-2. Sets wake schedule (every 15m)
-3. Installs cron to continue automatically
-4. Agent works until [done] or [blocked]
+2. Starts the agx daemon (if not running)
+3. Daemon wakes every 15m to continue work
+4. Runs until agent outputs [done] or [blocked]
 
-## Wake Loop
+## Daemon Management
 
-```
-WAKE (cron) → Load context → Agent works → Save state → SLEEP
-                                                    ↓
-                                        repeat until [done]
-```
-
-Install the wake schedule:
 ```bash
-mem cron export                          # View entry
-(crontab -l; mem cron export) | crontab - # Install
+agx daemon start    # Start background daemon
+agx daemon stop     # Stop daemon
+agx daemon status   # Check if running
+agx daemon logs     # Show recent logs
 ```
 
+The daemon:
+- Runs in background (survives terminal close)
+- Wakes every 15 minutes
+- Continues work on active tasks
+- Stops when task is [done] or [blocked]
+
 ## Output Markers
 
-Use these in agent output to control the loop:
+Use these in agent output to control state:
 
 ### Progress (parsed automatically)
 ```
@@ -63,17 +65,12 @@ Use these in agent output to control the loop:
 
 ### Stopping Markers
 ```
-[done]                  # Task complete, clear wake, stop
-[blocked: reason]       # Need human help, pause loop
+[done]                  # Task complete, stop
+[blocked: reason]       # Need human help, pause
 [approve: question]     # Need approval, wait
 [pause]                 # Stop, resume on next wake
 ```
 
-### Loop Control
-```
-[continue]              # Keep going (--daemon mode loops locally)
-```
-
 **Default behavior:** Keep working. Only output stopping markers when needed.
 
 ## Provider Aliases
@@ -87,11 +84,9 @@ Use these in agent output to control the loop:
 ## Common Flags
 
 ```bash
---auto-task         # Auto-create task from prompt
+--autonomous, -a    # Create task and run autonomously (starts daemon)
 --task NAME         # Specific task name
 --criteria "..."    # Success criterion (repeatable)
---daemon            # Loop on [continue] marker
---until-done        # Keep running until [done]
 -y                  # Skip confirmations
 ```
 
@@ -102,18 +97,18 @@ Use these in agent output to control the loop:
 agx claude -p "Explain this error" -y
 ```
 
-### Background task with wake
+### Autonomous task
 ```bash
 cd ~/Projects/api
-agx claude --auto-task -p "Add user authentication with JWT"
-# Agent works, saves progress, wakes every 15m to continue
+agx claude --autonomous -p "Add user authentication with JWT"
+# Daemon continues work every 15m until done
 ```
 
 ### Check on a running task
 ```bash
-mem status          # Quick summary
+agx daemon status   # Check daemon
+mem status          # Task summary
 mem progress        # % complete
-mem context         # Full state dump
 ```
 
 ### Manual continue