@mndrk/agx 1.4.0 → 1.4.2

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

@@ -80,6 +80,18 @@ Agents control state via markers in their output:
 --daemon               Loop on [continue] marker
 ```
 
+## Claude Code Plugin
+
+Install as a Claude Code plugin:
+
+```bash
+claude plugin install github:ramarlina/agx
+```
+
+This adds:
+- **Skill**: Claude learns how to spawn background agents
+- **Commands**: `/agx:spawn <goal>`, `/agx:continue`
+
 ## Commands
 
 ```bash

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

@@ -160,9 +160,18 @@ function findMemDir(startDir = process.cwd()) {
     if (fs.existsSync(indexFile)) {
       try {
         const index = JSON.parse(fs.readFileSync(indexFile, 'utf8'));
+        // Exact match
         if (index[startDir]) {
           return globalMem;
         }
+        // Check parent directories (for monorepo/subdirectory usage)
+        let checkDir = startDir;
+        while (checkDir !== path.dirname(checkDir)) {
+          checkDir = path.dirname(checkDir);
+          if (index[checkDir]) {
+            return globalMem;
+          }
+        }
       } catch {}
     }
   }
@@ -1340,12 +1349,17 @@ if ((options.autoTask || options.taskName) && !options.memDir && finalPrompt) {
     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();
-      const wakeCmd = `cd ${projectDir} && agx claude -p "continue"`;
+      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 -p "continue"${c.reset}\n`);
+      console.log(`${c.dim}       Run: agx claude -y -p "continue"${c.reset}\n`);
     } catch {}
     
   } catch (err) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mndrk/agx",
-  "version": "1.4.0",
+  "version": "1.4.2",
   "description": "Unified AI Agent Wrapper for Gemini, Claude, and Ollama",
   "main": "index.js",
   "bin": {
@@ -27,6 +27,6 @@
     "url": "https://github.com/ramarlina/agx"
   },
   "dependencies": {
-    "@mndrk/memx": "^0.2.0"
+    "@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
+```