@mndrk/agx 1.3.0 → 1.4.1

package/.claude/settings.local.json

@@ -4,7 +4,8 @@
       "Bash(node --check:*)",
       "Bash(node index.js:*)",
       "Bash(python:*)",
-      "Bash(npm publish:*)"
+      "Bash(npm publish:*)",
+      "Bash(npm uninstall:*)"
     ]
   }
 }

package/.claude-plugin/plugin.json

@@ -0,0 +1,7 @@
+{
+  "name": "agx",
+  "description": "Unified AI agent wrapper with persistent memory integration - spawn background agents that wake and continue",
+  "version": "1.4.0",
+  "author": "mndrk",
+  "repository": "https://github.com/ramarlina/agx"
+}

package/README.md

@@ -1,242 +1,153 @@
 # agx
 
-Unified AI Agent Wrapper for Gemini, Claude, and Ollama.
-
-## Installation
-
-### Via npm (recommended)
+Unified AI Agent CLI with persistent memory. Wraps Claude, Gemini, and Ollama with automatic state management via [mem](https://github.com/ramarlina/memx).
 
 ```bash
 npm install -g @mndrk/agx
 ```
 
-### From source
-
-Clone the repository and link locally:
-
-```bash
-git clone https://github.com/ramarlina/agx.git
-cd agx
-npm link
-```
-
 ## Quick Start
 
-When you run `agx` for the first time, it will automatically start the setup wizard:
-
 ```bash
-agx
-```
+# Simple prompt
+agx claude -p "explain this code"
 
-The setup wizard will:
-1. Detect which AI providers are installed on your system
-2. Guide you through installing any missing providers
-3. Help you authenticate with your chosen providers
-4. Set your default provider
+# Use default provider
+agx -p "what does this function do?"
 
-After setup, you can start using agx immediately:
+# With persistent memory (auto-detected)
+agx claude -p "continue working on the todo app"
 
-```bash
-agx --prompt "hello world"
+# Auto-create task (for agents, non-interactive)
+agx claude --auto-task -p "Build a todo app with React"
 ```
 
-## Usage
-
-### With Default Provider
+## Memory Integration
 
-Once configured, you can run prompts without specifying a provider:
+agx integrates with [mem](https://github.com/ramarlina/memx) for persistent state across sessions:
 
 ```bash
-agx --prompt "explain this code"
-agx -p "summarize the file"
-```
+# If ~/.mem has a task mapped to cwd, context is auto-loaded
+cd ~/Projects/my-app
+agx claude -p "continue"   # Knows where it left off
 
-### With Specific Provider
-
-```bash
-agx <provider> [options] --prompt "<prompt>"
+# Create task with explicit criteria
+agx claude --task todo-app \
+  --criteria "CRUD working" \
+  --criteria "Tests passing" \
+  --criteria "Deployed to Vercel" \
+  -p "Build a todo app"
 ```
 
-### Providers
-
-| Provider | Aliases | Backend |
-|----------|---------|---------|
-| `gemini` | `gem`, `g` | Google Gemini CLI |
-| `claude` | `cl`, `c` | Anthropic Claude CLI |
-| `ollama` | `ol`, `o` | Local Ollama via Claude interface |
+## Output Markers
 
-### Options
+Agents control state via markers in their output:
 
-| Option | Short | Description |
-|--------|-------|-------------|
-| `--prompt <text>` | `-p` | The prompt to send |
-| `--model <name>` | `-m` | Model name to use |
-| `--yolo` | `-y` | Skip permission prompts |
-| `--print` | | Non-interactive mode (output and exit) |
-| `--interactive` | `-i` | Force interactive mode |
-| `--sandbox` | `-s` | Enable sandbox (gemini only) |
-| `--debug` | `-d` | Enable debug output |
-| `--mcp <config>` | | MCP config file (claude/ollama only) |
-
-### Raw Passthrough
-
-Use `--` to pass arguments directly to the underlying CLI:
-```bash
-agx claude -- --resume
 ```
-
-## Configuration Commands
-
-### `agx init`
-
-Run the setup wizard manually. This is useful if you want to reconfigure agx or add new providers:
-
-```bash
-agx init
+[checkpoint: Hero section complete]   # Save progress
+[learn: Tailwind is fast]             # Record learning
+[next: Add auth system]               # Set next step
+[criteria: 2]                         # Mark criterion #2 done
+[approve: Deploy to production?]      # Halt for approval
+[blocked: Need API key from client]   # Mark stuck
+[pause]                               # Stop, resume later
+[continue]                            # Keep going (daemon)
+[done]                                # Task complete
+[split: auth "Handle authentication"] # Create subtask
 ```
 
-The wizard will:
-- Detect installed providers (claude, gemini, ollama)
-- Guide you through installation and authentication
-- Let you set or change your default provider
+## Providers
 
-### `agx config`
+| Provider | Aliases | Description |
+|----------|---------|-------------|
+| claude | c, cl | Anthropic Claude Code |
+| gemini | g, gem | Google Gemini CLI |
+| ollama | o, ol | Local Ollama models |
 
-Open an interactive configuration menu to manage your agx settings:
+## Options
 
-```bash
-agx config
 ```
-
-### `agx add <provider>`
-
-Install a specific AI provider:
-
-```bash
-agx add claude    # Install Claude CLI
-agx add gemini    # Install Gemini CLI
-agx add ollama    # Install Ollama
+--prompt, -p <text>    Prompt to send
+--model, -m <name>     Model name
+--yolo, -y             Skip permission prompts
+--print                Non-interactive output
+--interactive, -i      Force interactive mode
+--mem                  Enable mem integration (auto-detected)
+--no-mem               Disable mem integration
+--auto-task            Auto-create task from prompt
+--task <name>          Specific task name
+--criteria <text>      Success criterion (repeatable)
+--daemon               Loop on [continue] marker
 ```
 
-### `agx login <provider>`
+## Claude Code Plugin
 
-Authenticate with a provider:
+Install as a Claude Code plugin:
 
 ```bash
-agx login claude    # Login to Claude
-agx login gemini    # Login to Gemini
+claude plugin install github:ramarlina/agx
 ```
 
-### `agx status`
+This adds:
+- **Skill**: Claude learns how to spawn background agents
+- **Commands**: `/agx:spawn <goal>`, `/agx:continue`
 
-View your current configuration, including installed providers and default settings:
+## Commands
 
 ```bash
-agx status
-```
-
-Example output:
+agx init               # Setup wizard
+agx config             # Configuration menu
+agx status             # Show current config
+agx skill              # View LLM skill
+agx skill install      # Install skill to Claude/Gemini
 ```
-agx Configuration Status
-------------------------
-Default Provider: claude
-
-Installed Providers:
-  ✓ claude (authenticated)
-  ✓ gemini (authenticated)
-  ✓ ollama (running)
 
-Config file: ~/.agx/config.json
-```
+## Loop Control
 
-## Skill System
+The agent controls execution flow via markers:
 
-agx includes a skill system that helps AI agents understand how to use agx effectively.
+- `[done]` → Task complete, exit
+- `[pause]` → Save state, exit (resume later with same command)
+- `[blocked: reason]` → Mark stuck, notify human, exit
+- `[continue]` → Keep going (daemon mode loops)
+- `[approve: question]` → Halt until human approves
 
-### `agx skill`
+## Task Splitting
 
-View the agx skill (LLM instructions):
+Break large tasks into subtasks:
 
-```bash
-agx skill
 ```
+Agent output:
+This is too big. Breaking it down.
 
-This displays the skill file that describes agx's capabilities and usage patterns for AI agents.
-
-### `agx skill install`
-
-Install the agx skill to Claude and/or Gemini so AI agents know how to use agx:
-
-```bash
-agx skill install
+[split: setup "Project scaffolding"]
+[split: auth "Authentication system"]
+[split: crud "CRUD operations"]
+[next: Start with setup subtask]
+[pause]
 ```
 
-This adds the agx skill to your AI provider's skill directory, enabling features like:
-- AI agents can call other AI providers through agx
-- Cross-provider collaboration (e.g., Claude can ask Gemini for help)
-- Consistent command patterns across all providers
-
-## LLM-Predictable Command Patterns
+agx creates subtask branches in ~/.mem linked to the parent.
 
-For LLMs constructing commands, use these canonical patterns:
+## Example: Full Workflow
 
 ```bash
-# Pattern: agx --prompt "<prompt>" (uses default provider)
-agx --prompt "explain this code"
-
-# Pattern: agx <provider> --prompt "<prompt>"
-agx claude --prompt "explain this code"
-agx gemini --prompt "summarize the file"
-agx ollama --prompt "write a function"
-
-# Pattern: agx <provider> --model <model> --prompt "<prompt>"
-agx claude --model claude-sonnet-4-20250514 --prompt "fix the bug"
-agx gemini --model gemini-2.0-flash --prompt "optimize this"
-agx ollama --model qwen3:8b --prompt "refactor"
-
-# Pattern: agx <provider> --yolo --prompt "<prompt>"
-agx claude --yolo --prompt "run the tests"
+# Day 1: Start project
+mkdir ~/Projects/my-app && cd ~/Projects/my-app
+agx claude --auto-task -p "Build a React todo app with auth"
 
-# Pattern: agx <provider> --print --prompt "<prompt>"
-agx claude --print --prompt "what is 2+2"
-```
-
-### Command Structure
-
-```
-agx [provider] [--model <name>] [--yolo] [--print] --prompt "<prompt>"
-```
+# Agent works, outputs markers
+# [checkpoint: Scaffolded with Vite]
+# [learn: Vite is faster than CRA]
+# [next: Add todo list component]
+# [pause]
 
-**Rules for LLMs:**
-1. Always use `--prompt` flag for the prompt text
-2. Quote the prompt with double quotes
-3. Place options before `--prompt`
-4. Use full provider names (`claude`, `gemini`, `ollama`) for clarity
-5. Provider is optional if a default is configured
-
-## Configuration File
-
-agx stores its configuration in `~/.agx/config.json`:
-
-```json
-{
-  "defaultProvider": "claude",
-  "providers": {
-    "claude": {
-      "installed": true,
-      "authenticated": true
-    },
-    "gemini": {
-      "installed": true,
-      "authenticated": true
-    },
-    "ollama": {
-      "installed": true
-    }
-  }
-}
+# Day 2: Continue
+cd ~/Projects/my-app
+agx claude -p "continue"
+# Context auto-loaded, agent picks up where it left off
 ```
 
-## Ollama Support
+## License
 
-`agx ollama` automatically configures the environment to use a local Ollama instance as the backend for Claude Code. Default model is `glm-4.7:cloud` unless specified with `--model`.
+MIT

package/commands/continue.md

@@ -0,0 +1,16 @@
+# /agx:continue - Continue Current Task
+
+Continue working on the current task from the last checkpoint.
+
+## Usage
+```
+/agx:continue
+```
+
+## Implementation
+
+```bash
+agx claude -p "continue"
+```
+
+This loads the mem context and continues from where the task left off.

package/commands/spawn.md

@@ -0,0 +1,31 @@
+# /agx:spawn - Spawn Background Agent
+
+Spawn a background agent task with automatic wake schedule.
+
+## Usage
+```
+/agx:spawn <goal>
+```
+
+## Arguments
+- `$ARGUMENTS` - The goal/task description for the agent
+
+## Implementation
+
+First, ensure you're in the correct project directory, then:
+
+```bash
+agx claude --auto-task -p "$ARGUMENTS"
+```
+
+This will:
+1. Create a mem task branch
+2. Set wake schedule (every 15m)
+3. Start the agent working
+
+After spawning, install the wake cron:
+```bash
+(crontab -l 2>/dev/null; mem cron export) | crontab -
+```
+
+Report the task name and confirm wake schedule is set.

package/index.js

@@ -12,18 +12,54 @@ const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
 // agx skill - instructions for LLMs on how to use agx
 const AGX_SKILL = `---
 name: agx
-description: Use agx to run AI agents (Claude, Gemini, Ollama) from the command line
+description: Run AI agents with persistent memory. Wraps Claude, Gemini, Ollama with automatic state management.
 ---
 
-# agx - Unified AI Agent CLI
+# agx - AI Agent CLI with Persistent Memory
 
-Use \`agx\` to run AI agents from the command line. It wraps Claude Code, Gemini CLI, and Ollama.
+Run AI agents with automatic state persistence via mem integration.
 
-## Syntax
+## Basic Usage
 
 \`\`\`bash
-agx <provider> [options] --prompt "<prompt>"
-agx [options] --prompt "<prompt>"   # uses default provider
+agx claude -p "explain this code"     # simple prompt
+agx -p "what does this do?"           # use default provider
+agx c --yolo -p "fix the bug"         # skip confirmations
+\`\`\`
+
+## Memory Integration
+
+agx auto-detects \`~/.mem\` and loads context:
+
+\`\`\`bash
+# Auto-load context if task exists for cwd
+agx claude -p "continue working"
+
+# Auto-create task (non-interactive, for agents)
+agx claude --auto-task -p "Build todo app"
+
+# Explicit task with criteria
+agx claude --task todo-app \\
+  --criteria "CRUD working" \\
+  --criteria "Deployed" \\
+  -p "Build a todo app"
+\`\`\`
+
+## Output Markers
+
+Use these in agent output to save state:
+
+\`\`\`
+[checkpoint: message]      Save progress point
+[learn: insight]           Record learning
+[next: step]               Set next step
+[criteria: N]              Mark criterion #N complete
+[approve: question]        Halt for human approval
+[blocked: reason]          Mark blocked, stop
+[pause]                    Save and stop (resume later)
+[continue]                 Keep going (daemon mode)
+[done]                     Mark task complete
+[split: name "goal"]       Create subtask
 \`\`\`
 
 ## Providers
@@ -34,41 +70,50 @@ agx [options] --prompt "<prompt>"   # uses default provider
 | gemini | g, gem | Google Gemini CLI |
 | ollama | o, ol | Local Ollama models |
 
-## Common Options
+## Options
 
-| Option | Short | Description |
-|--------|-------|-------------|
-| --prompt | -p | The prompt to send |
-| --model | -m | Model name to use |
-| --yolo | -y | Skip permission prompts |
-| --print | | Non-interactive output |
-| --interactive | -i | Force interactive mode |
+| Option | Description |
+|--------|-------------|
+| --prompt, -p | The prompt to send |
+| --model, -m | Model name |
+| --yolo, -y | Skip permission prompts |
+| --mem | Enable mem (auto-detected) |
+| --no-mem | Disable mem |
+| --auto-task | Auto-create task from prompt |
+| --task NAME | Specific task name |
+| --criteria "..." | Success criterion (repeatable) |
+| --daemon | Loop on [continue] marker |
+| --until-done | Keep running until [done] |
 
-## Examples
+## Continuous Work Loop
 
-\`\`\`bash
-# Simple prompt
-agx claude --prompt "explain this code"
+New tasks auto-set \`wake: every 15m\`. The loop:
 
-# Use default provider
-agx --prompt "what does this function do?"
+\`\`\`
+WAKE → load context → review → work → save → SLEEP
+                                          ↓
+                              repeat until [done]
+\`\`\`
 
-# Skip confirmations
-agx c --yolo --prompt "fix the tests"
+Agent keeps working by default. Only output stopping markers when needed:
+- \`[done]\` → task complete, stop loop
+- \`[blocked: reason]\` → need human help, pause loop
+- \`[approve: question]\` → need approval, wait
 
-# Specify model
-agx ollama --model qwen3:8b --prompt "write a function"
+Install wake: \`mem cron export >> crontab\`
 
-# Non-interactive (just output)
-agx gemini --print --prompt "summarize README.md"
-\`\`\`
+## Task Splitting
+
+Break large tasks into subtasks:
 
-## When to use agx
+\`\`\`
+[split: setup "Project scaffolding"]
+[split: auth "Authentication system"]
+[split: crud "CRUD operations"]
+[next: Start with setup]
+\`\`\`
 
-- Quick AI queries from terminal
-- Running prompts across different AI providers
-- Scripting AI interactions
-- When you need --yolo mode to skip confirmations
+Creates subtask branches in ~/.mem, linked to parent.
 `;
 
 // ANSI colors
@@ -94,6 +139,201 @@ function commandExists(cmd) {
   }
 }
 
+// ==================== MEM INTEGRATION ====================
+
+// Find .mem directory (walk up from cwd, or check ~/.mem)
+function findMemDir(startDir = process.cwd()) {
+  // First check local .mem
+  let dir = startDir;
+  while (dir !== path.dirname(dir)) {
+    const memDir = path.join(dir, '.mem');
+    if (fs.existsSync(memDir) && fs.existsSync(path.join(memDir, '.git'))) {
+      return memDir;
+    }
+    dir = path.dirname(dir);
+  }
+  
+  // Then check ~/.mem with index
+  const globalMem = path.join(process.env.HOME || process.env.USERPROFILE, '.mem');
+  if (fs.existsSync(globalMem)) {
+    const indexFile = path.join(globalMem, 'index.json');
+    if (fs.existsSync(indexFile)) {
+      try {
+        const index = JSON.parse(fs.readFileSync(indexFile, 'utf8'));
+        if (index[startDir]) {
+          return globalMem;
+        }
+      } catch {}
+    }
+  }
+  
+  return null;
+}
+
+// Load mem context
+function loadMemContext(memDir) {
+  try {
+    const result = execSync('mem context', { 
+      cwd: path.dirname(memDir),
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe']
+    });
+    return result.trim();
+  } catch {
+    return null;
+  }
+}
+
+// Parse output markers
+function parseMemMarkers(output) {
+  const markers = [];
+  const patterns = [
+    { type: 'checkpoint', regex: /\[checkpoint:\s*([^\]]+)\]/gi },
+    { type: 'learn', regex: /\[learn:\s*([^\]]+)\]/gi },
+    { type: 'next', regex: /\[next:\s*([^\]]+)\]/gi },
+    { type: 'stuck', regex: /\[stuck:\s*([^\]]+)\]/gi },
+    { type: 'blocked', regex: /\[blocked:\s*([^\]]+)\]/gi },
+    { type: 'done', regex: /\[done\]/gi },
+    { type: 'pause', regex: /\[pause(?::\s*([^\]]*))?\]/gi },
+    { type: 'continue', regex: /\[continue\]/gi },
+    { type: 'approve', regex: /\[approve:\s*([^\]]+)\]/gi },
+    { type: 'criteria', regex: /\[criteria:\s*(\d+)\]/gi },
+    { type: 'split', regex: /\[split:\s*([^\s\]]+)(?:\s+"([^"]+)")?\]/gi },
+  ];
+  
+  for (const { type, regex } of patterns) {
+    let match;
+    while ((match = regex.exec(output)) !== null) {
+      if (type === 'split') {
+        markers.push({ type, name: match[1], goal: match[2] || match[1] });
+      } else {
+        markers.push({ type, value: match[1] || true });
+      }
+    }
+  }
+  
+  return markers;
+}
+
+// Apply mem markers - returns control signals
+function applyMemMarkers(markers, memDir) {
+  const workDir = path.dirname(memDir);
+  const result = {
+    approvals: [],
+    shouldContinue: false,
+    shouldPause: false,
+    isDone: false,
+    isBlocked: false,
+    splits: []
+  };
+  
+  for (const marker of markers) {
+    try {
+      switch (marker.type) {
+        case 'checkpoint':
+          execSync(`mem checkpoint "${marker.value.replace(/"/g, '\\"')}"`, { 
+            cwd: workDir, stdio: 'ignore' 
+          });
+          console.log(`${c.green}✓${c.reset} ${c.dim}Checkpoint:${c.reset} ${marker.value}`);
+          break;
+        case 'learn':
+          execSync(`mem learn "${marker.value.replace(/"/g, '\\"')}"`, { 
+            cwd: workDir, stdio: 'ignore' 
+          });
+          console.log(`${c.green}✓${c.reset} ${c.dim}Learned:${c.reset} ${marker.value}`);
+          break;
+        case 'next':
+          execSync(`mem next "${marker.value.replace(/"/g, '\\"')}"`, { 
+            cwd: workDir, stdio: 'ignore' 
+          });
+          console.log(`${c.green}✓${c.reset} ${c.dim}Next:${c.reset} ${marker.value}`);
+          break;
+        case 'stuck':
+        case 'blocked':
+          execSync(`mem stuck "${marker.value.replace(/"/g, '\\"')}"`, { 
+            cwd: workDir, stdio: 'ignore' 
+          });
+          console.log(`${c.yellow}⚠${c.reset} ${c.dim}Blocked:${c.reset} ${marker.value}`);
+          result.isBlocked = true;
+          break;
+        case 'done':
+          console.log(`${c.green}✓${c.reset} ${c.dim}Task marked done${c.reset}`);
+          result.isDone = true;
+          break;
+        case 'pause':
+          console.log(`${c.cyan}⏸${c.reset} ${c.dim}Pausing${marker.value ? ': ' + marker.value : ''}${c.reset}`);
+          result.shouldPause = true;
+          break;
+        case 'continue':
+          console.log(`${c.cyan}▶${c.reset} ${c.dim}Continuing...${c.reset}`);
+          result.shouldContinue = true;
+          break;
+        case 'approve':
+          result.approvals.push(marker.value);
+          break;
+        case 'criteria':
+          execSync(`mem criteria ${marker.value}`, { 
+            cwd: workDir, stdio: 'ignore' 
+          });
+          console.log(`${c.green}✓${c.reset} ${c.dim}Criteria #${marker.value} complete${c.reset}`);
+          break;
+        case 'split':
+          result.splits.push({ name: marker.name, goal: marker.goal });
+          console.log(`${c.cyan}⑂${c.reset} ${c.dim}Split:${c.reset} ${marker.name} - ${marker.goal}`);
+          break;
+      }
+    } catch (err) {
+      console.error(`${c.red}mem error:${c.reset} ${err.message}`);
+    }
+  }
+  
+  return result;
+}
+
+// Create subtasks from split markers
+function createSubtasks(splits, memDir) {
+  const workDir = path.dirname(memDir);
+  
+  for (const split of splits) {
+    try {
+      // Create subtask as new branch
+      execSync(`mem init ${split.name} "${split.goal.replace(/"/g, '\\"')}"`, {
+        cwd: workDir,
+        stdio: 'ignore'
+      });
+      console.log(`${c.green}✓${c.reset} Created subtask: ${c.bold}${split.name}${c.reset}`);
+    } catch (err) {
+      console.error(`${c.red}Failed to create subtask ${split.name}:${c.reset} ${err.message}`);
+    }
+  }
+}
+
+// Handle approval prompts
+async function handleApprovals(approvals) {
+  if (approvals.length === 0) return true;
+  
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  
+  for (const approval of approvals) {
+    const answer = await new Promise(resolve => {
+      rl.question(`\n${c.yellow}⚠ APPROVAL REQUIRED:${c.reset} ${approval}\n${c.dim}Continue? [y/N]:${c.reset} `, resolve);
+    });
+    
+    if (answer.toLowerCase() !== 'y' && answer.toLowerCase() !== 'yes') {
+      console.log(`${c.red}✗${c.reset} Rejected. Workflow halted.`);
+      rl.close();
+      return false;
+    }
+    console.log(`${c.green}✓${c.reset} Approved.`);
+  }
+  
+  rl.close();
+  return true;
+}
+
 // Load config
 function loadConfig() {
   try {
@@ -862,7 +1102,15 @@ const options = {
   interactive: false,
   sandbox: false,
   debug: false,
-  mcp: null
+  mcp: null,
+  mem: false,
+  memDir: null,
+  autoTask: false,
+  taskName: null,
+  criteria: [],
+  daemon: false,
+  untilDone: false,
+  wakeInterval: null
 };
 
 // Collect positional args (legacy support, but --prompt is preferred)
@@ -912,6 +1160,42 @@ for (let i = 0; i < processedArgs.length; i++) {
         i++;
       }
       break;
+    case '--mem':
+      options.mem = true;
+      break;
+    case '--no-mem':
+      options.mem = false;
+      break;
+    case '--auto-task':
+      options.autoTask = true;
+      options.mem = true;
+      break;
+    case '--task':
+      if (nextArg && !nextArg.startsWith('-')) {
+        options.taskName = nextArg;
+        options.mem = true;
+        i++;
+      }
+      break;
+    case '--criteria':
+      if (nextArg && !nextArg.startsWith('-')) {
+        options.criteria.push(nextArg);
+        i++;
+      }
+      break;
+    case '--daemon':
+      options.daemon = true;
+      break;
+    case '--until-done':
+      options.untilDone = true;
+      options.daemon = true;
+      break;
+    case '--wake':
+      if (nextArg && !nextArg.startsWith('-')) {
+        options.wakeInterval = nextArg;
+        i++;
+      }
+      break;
     default:
       if (arg.startsWith('-')) {
         // Unknown flag - pass through
@@ -986,29 +1270,214 @@ if (provider === 'gemini') {
 // Append raw args at the end
 translatedArgs.push(...rawArgs);
 
-const child = spawn(command, translatedArgs, {
-  env,
-  stdio: 'inherit',
-  shell: false
-});
-
-child.on('exit', (code) => {
-  process.exit(code || 0);
-});
-
-child.on('error', (err) => {
-  if (err.code === 'ENOENT') {
-    console.error(`${c.red}Error:${c.reset} "${command}" command not found.`);
-    console.error(`\n${c.dim}Install it first:${c.reset}`);
-    if (command === 'claude') {
-      console.error(`  npm install -g @anthropic-ai/claude-code`);
-    } else if (command === 'gemini') {
-      console.error(`  npm install -g @anthropic-ai/gemini-cli`);
+// ==================== MEM INTEGRATION ====================
+
+// Auto-detect mem if .mem exists (unless --no-mem)
+let memDir = options.mem !== false ? findMemDir() : null;
+if (memDir && options.mem !== false) {
+  options.mem = true;
+  options.memDir = memDir;
+}
+
+// Auto-create task if --auto-task or --task specified but no mem found
+if ((options.autoTask || options.taskName) && !options.memDir && finalPrompt) {
+  const taskName = options.taskName || finalPrompt
+    .toLowerCase()
+    .replace(/[^a-z0-9\s]/g, '')
+    .split(/\s+/)
+    .slice(0, 3)
+    .join('-');
+  
+  console.log(`${c.dim}[mem] Creating task: ${taskName}${c.reset}`);
+  
+  try {
+    // Build criteria args
+    const criteriaArgs = options.criteria.length 
+      ? options.criteria.map(c => `--criteria "${c}"`).join(' ')
+      : '';
+    
+    // Create task non-interactively
+    const centralMem = path.join(process.env.HOME || process.env.USERPROFILE, '.mem');
+    
+    // Ensure central mem exists
+    if (!fs.existsSync(centralMem)) {
+      fs.mkdirSync(centralMem, { recursive: true });
+      execSync('git init', { cwd: centralMem, stdio: 'ignore' });
+      fs.writeFileSync(path.join(centralMem, 'playbook.md'), '# Playbook\n\nGlobal learnings that transfer across tasks.\n');
+      execSync('git add -A && git commit -m "init: memory repo"', { cwd: centralMem, stdio: 'ignore', shell: true });
     }
-  } else {
-    console.error(`${c.red}Failed to start ${command}:${c.reset}`, err.message);
+    
+    // Create task branch
+    const branch = `task/${taskName}`;
+    try {
+      execSync(`git checkout main`, { cwd: centralMem, stdio: 'ignore' });
+    } catch {}
+    execSync(`git checkout -b ${branch}`, { cwd: centralMem, stdio: 'ignore' });
+    
+    // Create task files
+    const today = new Date().toISOString().split('T')[0];
+    const criteriaText = options.criteria.length 
+      ? options.criteria.map(c => `- [ ] ${c}`).join('\n')
+      : '- [ ] Define success criteria';
+    
+    fs.writeFileSync(path.join(centralMem, 'goal.md'), 
+      `---\ntask: ${taskName}\ncreated: ${today}\n---\n\n# Goal\n\n${finalPrompt}\n\n## Definition of Done\n\n${criteriaText}\n\n## Progress: 0%`);
+    fs.writeFileSync(path.join(centralMem, 'state.md'),
+      `---\nstatus: active\n---\n\n# State\n\n## Next Step\n\nBegin work\n\n## Checkpoints\n\n- [ ] Started`);
+    fs.writeFileSync(path.join(centralMem, 'memory.md'), '# Learnings\n\n');
+    
+    execSync('git add -A && git commit -m "init: ' + taskName + '"', { cwd: centralMem, stdio: 'ignore', shell: true });
+    
+    // Update index
+    const indexFile = path.join(centralMem, 'index.json');
+    let index = {};
+    try { index = JSON.parse(fs.readFileSync(indexFile, 'utf8')); } catch {}
+    index[process.cwd()] = branch;
+    fs.writeFileSync(indexFile, JSON.stringify(index, null, 2));
+    
+    options.memDir = centralMem;
+    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)
+    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`);
+    } catch {}
+    
+  } catch (err) {
+    console.error(`${c.yellow}Warning: Could not create task:${c.reset} ${err.message}`);
   }
-  process.exit(1);
-});
+}
+
+// Prepend mem context to prompt if mem is enabled
+if (options.mem && options.memDir && finalPrompt) {
+  const context = loadMemContext(options.memDir);
+  if (context) {
+    console.log(`${c.dim}[mem] Loaded context from ${options.memDir}${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.`;
+    
+    // Replace the prompt in translatedArgs
+    const promptIndex = translatedArgs.indexOf(finalPrompt);
+    if (promptIndex !== -1) {
+      translatedArgs[promptIndex] = augmentedPrompt;
+    }
+  }
+}
+
+// Run with mem output capture or normal mode
+if (options.mem && options.memDir) {
+  // Capture output for marker parsing
+  const child = spawn(command, translatedArgs, {
+    env,
+    stdio: ['inherit', 'pipe', 'inherit'],
+    shell: false
+  });
+  
+  let output = '';
+  
+  child.stdout.on('data', (data) => {
+    const text = data.toString();
+    output += text;
+    process.stdout.write(text);
+  });
+  
+  child.on('exit', async (code) => {
+    // Parse and apply mem markers
+    const markers = parseMemMarkers(output);
+    
+    if (markers.length > 0) {
+      console.log(`\n${c.dim}[mem] Processing markers...${c.reset}`);
+      const result = applyMemMarkers(markers, options.memDir);
+      
+      // Create subtasks if any
+      if (result.splits.length > 0) {
+        createSubtasks(result.splits, options.memDir);
+      }
+      
+      // Handle approvals
+      if (result.approvals.length > 0) {
+        const approved = await handleApprovals(result.approvals);
+        if (!approved) {
+          console.log(`${c.yellow}Workflow halted. Resume later.${c.reset}`);
+          process.exit(1);
+        }
+      }
+      
+      // Handle loop control - default is CONTINUE (wake again in 15m)
+      if (result.isDone) {
+        console.log(`\n${c.green}✓ Task complete!${c.reset}`);
+        // Clear wake schedule on done
+        try {
+          execSync('mem wake clear', { cwd: process.cwd(), stdio: 'ignore' });
+          console.log(`${c.dim}Wake schedule cleared.${c.reset}`);
+        } catch {}
+        process.exit(0);
+      } else if (result.isBlocked) {
+        console.log(`\n${c.yellow}⚠ Task blocked. Human intervention needed.${c.reset}`);
+        console.log(`${c.dim}Wake continues - run 'mem stuck clear' when unblocked.${c.reset}`);
+        process.exit(1);
+      } else if (options.untilDone) {
+        // Local loop mode: wait and run again
+        console.log(`\n${c.cyan}▶ Continuing in 10s...${c.reset}`);
+        setTimeout(() => {
+          const { spawnSync } = require('child_process');
+          spawnSync(process.argv[0], process.argv.slice(1), { stdio: 'inherit' });
+        }, 10000);
+        return;
+      } else {
+        // Default: save and exit, wake will resume in 15m
+        console.log(`\n${c.dim}Progress saved. Will continue on next wake (~15m).${c.reset}`);
+      }
+    }
+    
+    process.exit(code || 0);
+  });
+  
+  child.on('error', (err) => {
+    if (err.code === 'ENOENT') {
+      console.error(`${c.red}Error:${c.reset} "${command}" command not found.`);
+    } else {
+      console.error(`${c.red}Failed to start ${command}:${c.reset}`, err.message);
+    }
+    process.exit(1);
+  });
+} else {
+  // Normal mode - stdio inherit
+  const child = spawn(command, translatedArgs, {
+    env,
+    stdio: 'inherit',
+    shell: false
+  });
+
+  child.on('exit', (code) => {
+    process.exit(code || 0);
+  });
+
+  child.on('error', (err) => {
+    if (err.code === 'ENOENT') {
+      console.error(`${c.red}Error:${c.reset} "${command}" command not found.`);
+      console.error(`\n${c.dim}Install it first:${c.reset}`);
+      if (command === 'claude') {
+        console.error(`  npm install -g @anthropic-ai/claude-code`);
+      } else if (command === 'gemini') {
+        console.error(`  npm install -g @anthropic-ai/gemini-cli`);
+      }
+    } else {
+      console.error(`${c.red}Failed to start ${command}:${c.reset}`, err.message);
+    }
+    process.exit(1);
+  });
+}
 
 })();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mndrk/agx",
-  "version": "1.3.0",
+  "version": "1.4.1",
   "description": "Unified AI Agent Wrapper for Gemini, Claude, and Ollama",
   "main": "index.js",
   "bin": {
@@ -16,12 +16,17 @@
     "gemini",
     "claude",
     "ollama",
-    "llm"
+    "llm",
+    "memory",
+    "persistent"
   ],
-  "author": "mndrk",
+  "author": "Mendrika Ramarlina",
   "license": "MIT",
   "repository": {
     "type": "git",
     "url": "https://github.com/ramarlina/agx"
+  },
+  "dependencies": {
+    "@mndrk/memx": "^0.3.0"
   }
 }

package/skills/agx/SKILL.md

@@ -0,0 +1,123 @@
+# 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.
+
+## When to Use
+
+- **Spawning background agents** for long-running tasks
+- **Auto-task creation** with wake schedules
+- **Running different AI providers** with unified interface
+- **Autonomous work loops** that continue until done
+
+## Basic Usage
+
+```bash
+agx claude -p "prompt"              # Run Claude Code
+agx gemini -p "prompt"              # Run Gemini
+agx ollama -p "prompt"              # Run Ollama (local)
+```
+
+## Auto-Task Mode (Recommended)
+
+Create a task with automatic wake schedule:
+
+```bash
+cd ~/Projects/my-app
+agx claude --auto-task -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)
+```
+
+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]
+
+## Wake Loop
+
+```
+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
+```
+
+## Output Markers
+
+Use these in agent output to control the loop:
+
+### Progress (parsed automatically)
+```
+[checkpoint: message]   # Save progress point
+[learn: insight]        # Record learning
+[next: step]            # Set next step
+[criteria: N]           # Mark criterion #N complete
+```
+
+### Stopping Markers
+```
+[done]                  # Task complete, clear wake, stop
+[blocked: reason]       # Need human help, pause loop
+[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
+
+| Provider | Aliases | Description |
+|----------|---------|-------------|
+| claude | c, cl | Anthropic Claude Code |
+| gemini | g, gem | Google Gemini |
+| ollama | o, oll | Local Ollama |
+
+## Common Flags
+
+```bash
+--auto-task         # Auto-create task from prompt
+--task NAME         # Specific task name
+--criteria "..."    # Success criterion (repeatable)
+--daemon            # Loop on [continue] marker
+--until-done        # Keep running until [done]
+-y                  # Skip confirmations
+```
+
+## Examples
+
+### Quick one-shot
+```bash
+agx claude -p "Explain this error" -y
+```
+
+### Background task with wake
+```bash
+cd ~/Projects/api
+agx claude --auto-task -p "Add user authentication with JWT"
+# Agent works, saves progress, wakes every 15m to continue
+```
+
+### Check on a running task
+```bash
+mem status          # Quick summary
+mem progress        # % complete
+mem context         # Full state dump
+```
+
+### Manual continue
+```bash
+cd ~/Projects/api
+agx claude -p "continue"   # Resume from last checkpoint
+```