openrune 0.1.3 → 0.2.1

package/README.md

@@ -5,8 +5,8 @@
 <h1 align="center">Rune</h1>
 
 <p align="center">
-  <strong>File-based AI Agent Desktop App for Claude Code</strong><br/>
-  Drop a <code>.rune</code> file in any folder. Double-click to open. Chat with your AI agent.
+  <strong>File-based AI Agent Harness for Claude Code</strong><br/>
+  Drop a <code>.rune</code> file in any folder. Run it headlessly, chain agents, or open the desktop UI.
 </p>
 
 <p align="center">
@@ -19,27 +19,30 @@
 
 ## What is Rune?
 
-Rune turns any folder into an AI workspace. Each `.rune` file is an independent AI agent with its own chat history, role, and context — all powered by [Claude Code](https://docs.anthropic.com/en/docs/claude-code).
+Rune is a file-based agent harness for [Claude Code](https://docs.anthropic.com/en/docs/claude-code). Each `.rune` file is an independent AI agent with its own role, memory, and context. Run it from the CLI, chain agents together, automate with triggers, or open the desktop UI.
 
 - **File-based** — One `.rune` file = one agent. Move it, share it, version it with git.
-- **Folder-aware** — The agent knows your project. It can read files, run commands, and write code.
-- **Real-time activity** — See every tool call, permission request, and agent action as it happens via Claude Code hooks.
-- **Desktop-native** — Lightweight Electron app with built-in terminal. No browser needed.
-- **Right-click to create** — macOS Quick Action lets you create agents from Finder.
+- **Headless execution** — Run agents from the CLI or scripts. No GUI needed.
+- **Agent chaining** — Pipe agents together in a pipeline. Output → input, automatically.
+- **Automated triggers** — Run agents on file changes, git commits, or a cron schedule.
+- **Node.js API** — Use agents programmatically with `require('openrune')`.
+- **Desktop UI** — Chat interface with real-time activity monitoring and built-in terminal.
 
 ---
 
 ## Why Rune?
 
-Most AI tools lose context when you close the window. Rune doesn't — because your agent lives in your folder.
+Building a Claude Code harness usually means wiring up process management, I/O parsing, state handling, and a UI from scratch. Rune lets you skip all of that — just drop a file and go.
 
-**Persistent context** — Your agent remembers everything. Close the app, reopen it next week — the conversation and context are right where you left off.
+**No harness boilerplate** — No SDK wiring, no process management, no custom I/O parsing. One `.rune` file gives you a fully working agent you can run from CLI, scripts, or the desktop UI.
 
-**Portable** — The `.rune` file is just a file. Copy it to another machine, share it with a teammate, or check it into git. Your agent goes wherever the file goes.
+**Persistent context** — Role, memory, and chat history live in the `.rune` file. Close the app, reopen it next week — the agent picks up right where you left off.
 
-**Multiple agents per folder** — Need a code reviewer AND a backend developer in the same project? Create two `.rune` files. Each agent has its own role, history, and expertise — working side by side in the same folder.
+**Portable & shareable** — The `.rune` file is just JSON. Commit it to git, share it with teammates, or move it to another machine. The agent goes wherever the file goes.
 
-**No setup per project** — No config files, no extensions, no workspace settings. Drop a `.rune` file and you're ready.
+**Multiple agents per project** — A reviewer, a backend dev, a designer — each with its own role and history, working side by side in the same folder.
+
+**Scriptable** — Chain agents, set up triggers, or call agents from your own code via the Node.js API. One file format, multiple ways to use it.
 
 <p align="center">
   <img src="demo.gif" width="100%" alt="Rune demo" />
@@ -73,39 +76,65 @@ Or right-click any folder in Finder → Quick Actions → **New Rune**
   <img src="Screenshot.png" width="500" alt="Right-click to create a Rune agent" />
 </p>
 
-### 3. Open and chat
+### 3. Use it
 
-**Double-click** the `.rune` file, or:
+**Desktop UI** — Double-click the `.rune` file, or:
 
 ```bash
 rune open myagent.rune
 ```
 
+**Headless** — Run from the CLI without a GUI:
+
+```bash
+rune run myagent.rune "Explain this project's architecture"
+```
+
 ---
 
-## Features
+## Use Cases
+
+**Solo dev workflow** — Create `reviewer.rune` and `coder.rune` in your project. Use one to write code, the other to review it. Each agent keeps its own context and history.
+
+**Automated code review** — Set up a trigger to review every commit automatically:
+```bash
+rune watch reviewer.rune --on git-commit --prompt "Review this commit for bugs and security issues"
+```
+
+**CI/CD integration** — Run agents headlessly in your pipeline:
+```bash
+rune run qa.rune "Run tests and report any failures" --output json
+```
 
-### Chat UI
+**Agent pipeline** — Chain specialized agents for complex tasks:
+```bash
+rune pipe architect.rune coder.rune reviewer.rune "Add OAuth2 login flow"
+```
 
-- **Markdown rendering** — Code blocks, tables, lists with syntax highlighting.
-- **File attachment** — Drag and drop files or click to attach. The agent reads them from your filesystem.
-- **Stream cancellation** — Stop a response mid-stream.
-- **Chat history** — Persisted in the `.rune` file. Clear anytime.
+**Team collaboration** — Commit `.rune` files to git. Your teammates get the same agent with the same role and memory — no setup needed.
 
-### Real-time Activity Monitoring
+**Monitoring** — Schedule an agent to check things periodically:
+```bash
+rune watch ops.rune --on cron --interval 10m --prompt "Check if the API is healthy"
+```
 
-Rune uses [Claude Code hooks](https://docs.anthropic.com/en/docs/claude-code/hooks) to capture all agent activity in real-time:
+---
+
+## Features
 
-- **Tool calls** — See when the agent reads files, edits code, runs commands.
-- **Tool results** — See the output of each action.
-- **Permission requests** — Get notified when the agent needs approval.
-- **Session events** — Track when sessions start, stop, or encounter errors.
+### Harness
 
-No more guessing what the agent is doing — everything is visible in the chat panel.
+- **Headless execution** — `rune run` lets you run agents from the CLI, scripts, or CI/CD. No GUI needed.
+- **Agent chaining** — `rune pipe` connects agents in sequence. Each agent's output feeds into the next.
+- **Automated triggers** — `rune watch` runs agents on file changes, git commits, or a cron schedule.
+- **Node.js API** — `require('openrune')` to use agents programmatically in your own code.
+- **Persistent context** — Role, memory, and chat history are saved in the `.rune` file across sessions.
 
-### Built-in Terminal
+### Desktop UI
 
-Toggle the terminal panel to see raw Claude Code output or run your own commands alongside the agent.
+- **Chat interface** — Markdown rendering, file attachment, stream cancellation.
+- **Real-time activity** — See every tool call, result, and permission request as it happens via [Claude Code hooks](https://docs.anthropic.com/en/docs/claude-code/hooks).
+- **Built-in terminal** — Raw Claude Code output and your own commands, side by side.
 
 ### Agent Roles
 
@@ -144,30 +173,108 @@ Edit the `role` field anytime to change the agent's behavior.
 | `rune install` | Build app, register file association, install Quick Action |
 | `rune new <name>` | Create a `.rune` file in the current directory |
 | `rune new <name> --role "..."` | Create with a custom role |
-| `rune open <file.rune>` | Open a `.rune` file |
+| `rune open <file.rune>` | Open a `.rune` file (desktop GUI) |
+| `rune run <file.rune> "prompt"` | Run agent headlessly (no GUI) |
+| `rune pipe <a.rune> <b.rune> "prompt"` | Chain agents in a pipeline |
+| `rune watch <file.rune> --on <event>` | Set up automated triggers |
 | `rune list` | List `.rune` files in the current directory |
 | `rune uninstall` | Remove Rune integration (keeps your `.rune` files) |
 
 ---
 
-## Architecture
+## Harness Mode
+
+Rune isn't just a desktop app — it's a full agent harness. Use it from scripts, CI/CD, or your own tools.
+
+### Headless execution
+
+Run any `.rune` agent from the command line without opening the GUI:
+
+```bash
+rune run reviewer.rune "Review the latest commit"
 
+# Pipe input from other commands
+git diff | rune run reviewer.rune "Review this diff"
+
+# JSON output for scripting
+rune run reviewer.rune "Review src/auth.ts" --output json
 ```
-User ↔ Chat UI (React)
-         ↕ IPC
-       Electron Main Process
-         ↕ HTTP + SSE
-       MCP Channel (rune-channel)         Claude Code Hooks
-         ↕ MCP                              ↕ HTTP POST
-       Claude Code CLI  ──────────────→  rune-channel /hook
+
+### Agent chaining
+
+Chain multiple agents into a pipeline. The output of each agent becomes the input for the next:
+
+```bash
+rune pipe coder.rune reviewer.rune tester.rune "Implement a login page"
+```
+
+This runs: coder writes the code → reviewer reviews it → tester writes tests.
+
+### Automated triggers
+
+Set agents to run automatically on events:
+
+```bash
+# Run on every git commit
+rune watch reviewer.rune --on git-commit --prompt "Review this commit"
+
+# Watch for file changes
+rune watch linter.rune --on file-change --glob "src/**/*.ts" --prompt "Check for issues"
+
+# Run on a schedule
+rune watch monitor.rune --on cron --interval 5m --prompt "Check server health"
 ```
 
-**Two paths for data:**
+### Node.js API
+
+Use Rune agents programmatically in your own code:
+
+```js
+const rune = require('openrune')
+
+const reviewer = rune.load('reviewer.rune')
+const result = await reviewer.send('Review the latest commit')
+console.log(result)
+
+// Agent chaining via API
+const { finalOutput } = await rune.pipe(
+  ['coder.rune', 'reviewer.rune'],
+  'Implement a login page'
+)
+```
+
+---
+
+## Architecture
+
+```
+                    ┌─────────────────────────┐
+                    │      Desktop UI Mode     │
+                    │   User ↔ Chat UI (React) │
+                    │         ↕ IPC            │
+                    │   Electron Main Process  │
+                    │         ↕ HTTP + SSE     │
+                    └────────────┬────────────┘
+                                 │
+                    ┌────────────┴────────────┐
+                    │  MCP Channel             │     Claude Code Hooks
+                    │  (rune-channel)          │      ↕ HTTP POST
+                    │         ↕ MCP            │←──── rune-channel /hook
+                    └────────────┬────────────┘
+                                 │
+                    ┌────────────┴────────────┐
+                    │     Claude Code CLI      │
+                    └─────────────────────────┘
+
+   Harness Mode (rune run / pipe / watch):
+     CLI → Claude Code CLI (-p) → stdout
+     No MCP channel, no Electron — direct execution
+```
 
-1. **Chat input** → MCP channel → Claude Code (user messages)
-2. **Claude Code hooks** → rune-channel → SSE → Chat UI (activity monitoring)
+**Two modes of operation:**
 
-The hooks approach ensures Rune sees everything Claude does, without relying on the agent to self-report.
+1. **Desktop UI** — Chat input → MCP channel → Claude Code, with hooks for real-time activity monitoring.
+2. **Harness** — Direct CLI execution via `claude -p`. Agents run headlessly with context from the `.rune` file.
 
 ---
 
@@ -195,7 +302,8 @@ npm run build
 
 ```
 Rune/
-  bin/rune.js              # CLI tool (install, new, open, list)
+  bin/rune.js              # CLI (install, new, open, run, pipe, watch, list)
+  lib/index.js             # Node.js API (require('openrune'))
   src/
     main.ts                # Electron main process
     preload.ts             # Preload bridge (IPC security)

package/bin/rune.js

@@ -29,6 +29,9 @@ switch (command) {
   case 'install': return install()
   case 'new':     return createRune(args[0], args)
   case 'open':    return openRune(args[0])
+  case 'run':     return runRune(args[0], args.slice(1))
+  case 'pipe':    return pipeRunes(args)
+  case 'watch':   return watchRune(args[0], args.slice(1))
   case 'list':    return listRunes()
   case 'uninstall': return uninstall()
   case 'help':
@@ -649,6 +652,421 @@ function openRune(file) {
   child.unref()
 }
 
+// ── run (headless) ──────────────────────────────
+
+function runRune(file, restArgs) {
+  if (!file) {
+    console.log('Usage: rune run <file.rune> "prompt" [--output json|text]')
+    console.log('Example: rune run reviewer.rune "Review the latest commit"')
+    process.exit(1)
+  }
+
+  const filePath = path.resolve(process.cwd(), file)
+  if (!fs.existsSync(filePath)) {
+    console.error(`  ❌ File not found: ${filePath}`)
+    process.exit(1)
+  }
+
+  // Parse args: prompt and flags
+  let prompt = ''
+  let outputFormat = 'text'
+  for (let i = 0; i < restArgs.length; i++) {
+    if (restArgs[i] === '--output' && restArgs[i + 1]) {
+      outputFormat = restArgs[i + 1]
+      i++
+    } else if (!prompt) {
+      prompt = restArgs[i]
+    }
+  }
+
+  // Read from stdin if no prompt provided
+  if (!prompt && process.stdin.isTTY === false) {
+    prompt = fs.readFileSync('/dev/stdin', 'utf-8').trim()
+  }
+
+  if (!prompt) {
+    console.error('  ❌ No prompt provided. Pass a prompt string or pipe via stdin.')
+    process.exit(1)
+  }
+
+  const rune = JSON.parse(fs.readFileSync(filePath, 'utf-8'))
+  const folderPath = path.dirname(filePath)
+
+  // Build system prompt from .rune context
+  const systemParts = []
+  if (rune.role) systemParts.push(`Your role: ${rune.role}`)
+  if (rune.memory && rune.memory.length > 0) {
+    systemParts.push('Saved memory from previous sessions:')
+    rune.memory.forEach((m, i) => systemParts.push(`${i + 1}. ${m}`))
+  }
+  if (rune.history && rune.history.length > 0) {
+    const recent = rune.history.slice(-10)
+    systemParts.push(`\nRecent conversation (${rune.history.length} total, showing last ${recent.length}):`)
+    for (const msg of recent) {
+      const who = msg.role === 'user' ? 'User' : 'Assistant'
+      systemParts.push(`${who}: ${msg.text}`)
+    }
+  }
+
+  const systemPrompt = systemParts.join('\n')
+
+  // Build claude CLI args
+  const claudeArgs = ['-p', '--print']
+  if (systemPrompt) {
+    claudeArgs.push('--system-prompt', systemPrompt)
+  }
+  if (outputFormat === 'json') {
+    claudeArgs.push('--output-format', 'json')
+  }
+  claudeArgs.push(prompt)
+
+  const child = spawn('claude', claudeArgs, {
+    cwd: folderPath,
+    stdio: ['pipe', 'pipe', 'pipe'],
+    env: { ...process.env },
+  })
+
+  let stdout = ''
+  let stderr = ''
+
+  child.stdout.on('data', (data) => {
+    const text = data.toString()
+    stdout += text
+    if (outputFormat !== 'json') process.stdout.write(text)
+  })
+  child.stderr.on('data', (data) => { stderr += data.toString() })
+
+  child.on('close', (code) => {
+    if (outputFormat === 'json') {
+      try {
+        const parsed = JSON.parse(stdout)
+        console.log(JSON.stringify({ agent: rune.name, role: rune.role, response: parsed }, null, 2))
+      } catch {
+        console.log(JSON.stringify({ agent: rune.name, role: rune.role, response: stdout.trim() }, null, 2))
+      }
+    }
+
+    // Save to history
+    rune.history = rune.history || []
+    rune.history.push({ role: 'user', text: prompt, ts: Date.now() })
+    rune.history.push({ role: 'assistant', text: stdout.trim(), ts: Date.now() })
+    fs.writeFileSync(filePath, JSON.stringify(rune, null, 2))
+
+    if (code !== 0 && stderr) {
+      console.error(stderr)
+    }
+    process.exit(code || 0)
+  })
+}
+
+// ── pipe (agent chaining) ───────────────────────
+
+async function pipeRunes(args) {
+  // Parse: rune pipe agent1.rune agent2.rune ... "initial prompt" [--output json]
+  const runeFiles = []
+  let prompt = ''
+  let outputFormat = 'text'
+
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--output' && args[i + 1]) {
+      outputFormat = args[i + 1]
+      i++
+    } else if (args[i].endsWith('.rune')) {
+      runeFiles.push(args[i])
+    } else if (!prompt) {
+      prompt = args[i]
+    }
+  }
+
+  if (runeFiles.length < 2 || !prompt) {
+    console.log('Usage: rune pipe <agent1.rune> <agent2.rune> [...] "initial prompt"')
+    console.log('Example: rune pipe coder.rune reviewer.rune "Implement a login page"')
+    console.log('\nThe output of each agent becomes the input for the next.')
+    process.exit(1)
+  }
+
+  // Read from stdin if no prompt
+  if (!prompt && process.stdin.isTTY === false) {
+    prompt = fs.readFileSync('/dev/stdin', 'utf-8').trim()
+  }
+
+  let currentInput = prompt
+  const results = []
+
+  for (let i = 0; i < runeFiles.length; i++) {
+    const file = runeFiles[i]
+    const filePath = path.resolve(process.cwd(), file)
+
+    if (!fs.existsSync(filePath)) {
+      console.error(`  ❌ File not found: ${filePath}`)
+      process.exit(1)
+    }
+
+    const rune = JSON.parse(fs.readFileSync(filePath, 'utf-8'))
+    const folderPath = path.dirname(filePath)
+
+    const isLast = i === runeFiles.length - 1
+    const pipeContext = i > 0
+      ? `You are step ${i + 1} of ${runeFiles.length} in a pipeline. The previous agent (${results[i-1].agent}) produced the following output:\n\n${currentInput}\n\nNow do your part:`
+      : currentInput
+
+    if (outputFormat !== 'json') {
+      console.error(`\n  ▶ [${i + 1}/${runeFiles.length}] ${rune.name} (${rune.role || 'assistant'})`)
+    }
+
+    // Build system prompt
+    const systemParts = []
+    if (rune.role) systemParts.push(`Your role: ${rune.role}`)
+    if (rune.memory && rune.memory.length > 0) {
+      systemParts.push('Saved memory:')
+      rune.memory.forEach((m, j) => systemParts.push(`${j + 1}. ${m}`))
+    }
+
+    const claudeArgs = ['-p', '--print']
+    if (systemParts.length > 0) {
+      claudeArgs.push('--system-prompt', systemParts.join('\n'))
+    }
+    claudeArgs.push(pipeContext)
+
+    const output = await new Promise((resolve, reject) => {
+      const child = spawn('claude', claudeArgs, {
+        cwd: folderPath,
+        stdio: ['pipe', 'pipe', 'pipe'],
+        env: { ...process.env },
+      })
+
+      let stdout = ''
+      let stderr = ''
+      child.stdout.on('data', (d) => { stdout += d.toString() })
+      child.stderr.on('data', (d) => { stderr += d.toString() })
+      child.on('close', (code) => {
+        if (code !== 0) reject(new Error(stderr || `Agent ${rune.name} exited with code ${code}`))
+        else resolve(stdout.trim())
+      })
+    })
+
+    results.push({ agent: rune.name, role: rune.role, output })
+
+    // Save to .rune history
+    rune.history = rune.history || []
+    rune.history.push({ role: 'user', text: pipeContext, ts: Date.now() })
+    rune.history.push({ role: 'assistant', text: output, ts: Date.now() })
+    fs.writeFileSync(filePath, JSON.stringify(rune, null, 2))
+
+    currentInput = output
+
+    // Print intermediate output
+    if (outputFormat !== 'json' && !isLast) {
+      console.error(`  ✓ Done\n`)
+    }
+  }
+
+  // Final output
+  if (outputFormat === 'json') {
+    console.log(JSON.stringify({ pipeline: results, finalOutput: currentInput }, null, 2))
+  } else {
+    console.log(currentInput)
+  }
+}
+
+// ── watch (triggers) ────────────────────────────
+
+function watchRune(file, restArgs) {
+  if (!file) {
+    console.log('Usage: rune watch <file.rune> --on <event> [options]')
+    console.log('')
+    console.log('Events:')
+    console.log('  file-change    Watch for file changes in the project folder')
+    console.log('  git-push       Run after git push (installs a git hook)')
+    console.log('  git-commit     Run after git commit (installs a git hook)')
+    console.log('  cron           Run on a schedule (e.g. --interval 5m)')
+    console.log('')
+    console.log('Options:')
+    console.log('  --prompt "..."       The prompt to send when triggered')
+    console.log('  --glob "*.ts"        File pattern to watch (for file-change)')
+    console.log('  --interval 5m        Interval for cron (e.g. 30s, 5m, 1h)')
+    console.log('')
+    console.log('Examples:')
+    console.log('  rune watch reviewer.rune --on file-change --glob "src/**/*.ts" --prompt "Review changed files"')
+    console.log('  rune watch reviewer.rune --on git-commit --prompt "Review this commit"')
+    console.log('  rune watch monitor.rune --on cron --interval 5m --prompt "Check server status"')
+    process.exit(1)
+  }
+
+  const filePath = path.resolve(process.cwd(), file)
+  if (!fs.existsSync(filePath)) {
+    console.error(`  ❌ File not found: ${filePath}`)
+    process.exit(1)
+  }
+
+  // Parse args
+  let event = ''
+  let prompt = ''
+  let glob = ''
+  let interval = '5m'
+
+  for (let i = 0; i < restArgs.length; i++) {
+    if (restArgs[i] === '--on' && restArgs[i + 1]) { event = restArgs[++i] }
+    else if (restArgs[i] === '--prompt' && restArgs[i + 1]) { prompt = restArgs[++i] }
+    else if (restArgs[i] === '--glob' && restArgs[i + 1]) { glob = restArgs[++i] }
+    else if (restArgs[i] === '--interval' && restArgs[i + 1]) { interval = restArgs[++i] }
+  }
+
+  if (!event) {
+    console.error('  ❌ --on <event> is required')
+    process.exit(1)
+  }
+
+  if (!prompt) {
+    console.error('  ❌ --prompt is required')
+    process.exit(1)
+  }
+
+  const rune = JSON.parse(fs.readFileSync(filePath, 'utf-8'))
+  const folderPath = path.dirname(filePath)
+
+  function triggerRun(triggerInfo) {
+    const fullPrompt = triggerInfo
+      ? `[Triggered by: ${triggerInfo}]\n\n${prompt}`
+      : prompt
+    console.log(`\n🔮 [${new Date().toLocaleTimeString()}] Triggered: ${rune.name} — ${triggerInfo || event}`)
+
+    const systemParts = []
+    if (rune.role) systemParts.push(`Your role: ${rune.role}`)
+
+    const claudeArgs = ['-p', '--print']
+    if (systemParts.length > 0) {
+      claudeArgs.push('--system-prompt', systemParts.join('\n'))
+    }
+    claudeArgs.push(fullPrompt)
+
+    const child = spawn('claude', claudeArgs, {
+      cwd: folderPath,
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env: { ...process.env },
+    })
+
+    let stdout = ''
+    child.stdout.on('data', (d) => {
+      const text = d.toString()
+      stdout += text
+      process.stdout.write(text)
+    })
+    child.stderr.on('data', (d) => { process.stderr.write(d) })
+    child.on('close', () => {
+      // Save to history
+      const fresh = JSON.parse(fs.readFileSync(filePath, 'utf-8'))
+      fresh.history = fresh.history || []
+      fresh.history.push({ role: 'user', text: fullPrompt, ts: Date.now() })
+      fresh.history.push({ role: 'assistant', text: stdout.trim(), ts: Date.now() })
+      fs.writeFileSync(filePath, JSON.stringify(fresh, null, 2))
+      console.log(`\n✓ Done`)
+    })
+  }
+
+  // ── Event handlers ──
+
+  if (event === 'file-change') {
+    const watchDir = folderPath
+    console.log(`🔮 Watching ${watchDir} for file changes...`)
+    if (glob) console.log(`   Pattern: ${glob}`)
+    console.log(`   Agent: ${rune.name} (${rune.role || 'assistant'})`)
+    console.log('   Press Ctrl+C to stop\n')
+
+    let debounce = null
+    fs.watch(watchDir, { recursive: true }, (eventType, filename) => {
+      if (!filename) return
+      if (filename.endsWith('.rune')) return  // ignore .rune file changes
+      if (filename.startsWith('.git')) return
+      if (filename.includes('node_modules')) return
+
+      // Simple glob matching
+      if (glob) {
+        const ext = glob.replace('*', '')
+        if (!filename.endsWith(ext) && !filename.includes(glob.replace('*', ''))) return
+      }
+
+      // Debounce: wait 1s after last change
+      if (debounce) clearTimeout(debounce)
+      debounce = setTimeout(() => {
+        triggerRun(`file changed: ${filename}`)
+      }, 1000)
+    })
+  }
+
+  else if (event === 'git-commit' || event === 'git-push') {
+    const hookName = event === 'git-commit' ? 'post-commit' : 'post-push'
+    const gitDir = path.join(folderPath, '.git', 'hooks')
+
+    if (!fs.existsSync(path.join(folderPath, '.git'))) {
+      console.error('  ❌ Not a git repository')
+      process.exit(1)
+    }
+
+    ensureDir(gitDir)
+
+    // For git-push, use pre-push since post-push doesn't exist natively
+    const actualHook = event === 'git-push' ? 'pre-push' : 'post-commit'
+    const hookPath = path.join(gitDir, actualHook)
+    const runeBin = path.resolve(__dirname, 'rune.js')
+    const nodebin = process.execPath
+
+    const hookScript = `#!/bin/bash
+# Rune auto-trigger: ${rune.name}
+"${nodebin}" "${runeBin}" run "${filePath}" "${prompt.replace(/"/g, '\\"')}" &
+`
+
+    // Append if hook exists, create if not
+    if (fs.existsSync(hookPath)) {
+      const existing = fs.readFileSync(hookPath, 'utf-8')
+      if (!existing.includes('Rune auto-trigger')) {
+        fs.appendFileSync(hookPath, '\n' + hookScript)
+      } else {
+        console.log(`  ⚠️  Rune hook already installed in ${actualHook}`)
+        return
+      }
+    } else {
+      fs.writeFileSync(hookPath, hookScript, { mode: 0o755 })
+    }
+
+    console.log(`🔮 Git hook installed: ${actualHook}`)
+    console.log(`   Agent: ${rune.name} will run on every ${event.replace('git-', '')}`)
+    console.log(`   Prompt: "${prompt}"`)
+    console.log(`   Hook: ${hookPath}`)
+  }
+
+  else if (event === 'cron') {
+    const ms = parseInterval(interval)
+    console.log(`🔮 Running ${rune.name} every ${interval}`)
+    console.log(`   Prompt: "${prompt}"`)
+    console.log('   Press Ctrl+C to stop\n')
+
+    // Run immediately, then on interval
+    triggerRun(`cron (every ${interval})`)
+    setInterval(() => {
+      triggerRun(`cron (every ${interval})`)
+    }, ms)
+  }
+
+  else {
+    console.error(`  ❌ Unknown event: ${event}. Use: file-change, git-commit, git-push, cron`)
+    process.exit(1)
+  }
+}
+
+function parseInterval(str) {
+  const match = str.match(/^(\d+)(s|m|h)$/)
+  if (!match) {
+    console.error(`  ❌ Invalid interval: ${str}. Use format like 30s, 5m, 1h`)
+    process.exit(1)
+  }
+  const num = parseInt(match[1])
+  const unit = match[2]
+  if (unit === 's') return num * 1000
+  if (unit === 'm') return num * 60 * 1000
+  if (unit === 'h') return num * 60 * 60 * 1000
+}
+
 // ── list ─────────────────────────────────────────
 
 function listRunes() {
@@ -707,21 +1125,32 @@ function uninstall() {
 
 function showHelp() {
   console.log(`
-🔮 Rune — File-based AI Agent
+🔮 Rune — File-based AI Agent Harness
 
 Usage:
   rune install              Install Rune (build app, register file association, add Quick Action)
   rune new <name>           Create a new .rune file in current directory
     --role "description"    Set the agent's role
-  rune open <file.rune>     Open a .rune file
+  rune open <file.rune>     Open a .rune file (desktop GUI)
+  rune run <file.rune> "prompt"   Run agent headlessly (no GUI)
+    --output json|text      Output format (default: text)
+  rune pipe <a.rune> <b.rune> ... "prompt"   Chain agents in a pipeline
+    --output json|text      Output format (default: text)
+  rune watch <file.rune>    Set up automated triggers
+    --on <event>            Event: file-change, git-commit, git-push, cron
+    --prompt "..."          Prompt to send when triggered
+    --glob "*.ts"           File pattern (for file-change)
+    --interval 5m           Schedule interval (for cron: 30s, 5m, 1h)
   rune list                 List .rune files in current directory
   rune uninstall            Remove Rune integration (keeps .rune files)
   rune help                 Show this help
 
 Examples:
-  rune new designer --role "UI/UX design expert"
-  rune new backend --role "Backend developer, Node.js specialist"
-  rune open designer.rune
-  rune list
+  rune new reviewer --role "Code reviewer, security focused"
+  rune run reviewer.rune "Review the latest commit"
+  rune pipe coder.rune reviewer.rune "Implement a login page"
+  rune watch reviewer.rune --on git-commit --prompt "Review this commit"
+  rune watch monitor.rune --on cron --interval 5m --prompt "Check server health"
+  echo "Fix the bug in auth.ts" | rune run backend.rune
 `)
 }

package/lib/index.js

@@ -0,0 +1,116 @@
+/**
+ * OpenRune — Node.js API
+ *
+ * Usage:
+ *   const rune = require('openrune')
+ *   const agent = rune.load('reviewer.rune')
+ *   const result = await agent.send('Review this code')
+ */
+
+const { spawn } = require('child_process')
+const path = require('path')
+const fs = require('fs')
+
+function load(filePath) {
+  const resolved = path.resolve(filePath)
+  if (!fs.existsSync(resolved)) {
+    throw new Error(`Rune file not found: ${resolved}`)
+  }
+
+  const rune = JSON.parse(fs.readFileSync(resolved, 'utf-8'))
+  const folderPath = path.dirname(resolved)
+
+  return {
+    name: rune.name,
+    role: rune.role,
+    filePath: resolved,
+
+    async send(prompt) {
+      const fresh = JSON.parse(fs.readFileSync(resolved, 'utf-8'))
+
+      // Build system prompt
+      const systemParts = []
+      if (fresh.role) systemParts.push(`Your role: ${fresh.role}`)
+      if (fresh.memory && fresh.memory.length > 0) {
+        systemParts.push('Saved memory:')
+        fresh.memory.forEach((m, i) => systemParts.push(`${i + 1}. ${m}`))
+      }
+      if (fresh.history && fresh.history.length > 0) {
+        const recent = fresh.history.slice(-10)
+        systemParts.push(`\nRecent conversation (last ${recent.length}):`)
+        for (const msg of recent) {
+          const who = msg.role === 'user' ? 'User' : 'Assistant'
+          systemParts.push(`${who}: ${msg.text}`)
+        }
+      }
+
+      const claudeArgs = ['-p', '--print']
+      if (systemParts.length > 0) {
+        claudeArgs.push('--system-prompt', systemParts.join('\n'))
+      }
+      claudeArgs.push(prompt)
+
+      const result = await new Promise((resolve, reject) => {
+        const child = spawn('claude', claudeArgs, {
+          cwd: folderPath,
+          stdio: ['pipe', 'pipe', 'pipe'],
+          env: { ...process.env },
+        })
+
+        let stdout = ''
+        let stderr = ''
+        child.stdout.on('data', (d) => { stdout += d.toString() })
+        child.stderr.on('data', (d) => { stderr += d.toString() })
+        child.on('close', (code) => {
+          if (code !== 0) reject(new Error(stderr || `Exit code ${code}`))
+          else resolve(stdout.trim())
+        })
+      })
+
+      // Save to history
+      fresh.history = fresh.history || []
+      fresh.history.push({ role: 'user', text: prompt, ts: Date.now() })
+      fresh.history.push({ role: 'assistant', text: result, ts: Date.now() })
+      fs.writeFileSync(resolved, JSON.stringify(fresh, null, 2))
+
+      return result
+    },
+
+    getHistory() {
+      const fresh = JSON.parse(fs.readFileSync(resolved, 'utf-8'))
+      return fresh.history || []
+    },
+
+    getMemory() {
+      const fresh = JSON.parse(fs.readFileSync(resolved, 'utf-8'))
+      return fresh.memory || []
+    },
+
+    addMemory(text) {
+      const fresh = JSON.parse(fs.readFileSync(resolved, 'utf-8'))
+      fresh.memory = fresh.memory || []
+      fresh.memory.push(text)
+      fs.writeFileSync(resolved, JSON.stringify(fresh, null, 2))
+    },
+  }
+}
+
+async function pipe(runeFiles, prompt) {
+  let currentInput = prompt
+  const results = []
+
+  for (let i = 0; i < runeFiles.length; i++) {
+    const agent = load(runeFiles[i])
+    const input = i > 0
+      ? `Previous agent (${results[i-1].agent}) output:\n\n${currentInput}\n\nNow do your part:`
+      : currentInput
+
+    const output = await agent.send(input)
+    results.push({ agent: agent.name, role: agent.role, output })
+    currentInput = output
+  }
+
+  return { pipeline: results, finalOutput: currentInput }
+}
+
+module.exports = { load, pipe }

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "openrune",
-  "version": "0.1.3",
-  "description": "Rune — File-based AI Agent Desktop App",
-  "keywords": ["ai", "agent", "claude", "desktop", "electron", "mcp", "claude-code"],
+  "version": "0.2.1",
+  "description": "Rune — File-based AI Agent Harness for Claude Code",
+  "keywords": ["ai", "agent", "claude", "desktop", "electron", "mcp", "claude-code", "harness", "automation"],
   "repository": {
     "type": "git",
     "url": "https://github.com/gilhyun/Rune.git"
@@ -11,6 +11,9 @@
   "license": "MIT",
   "author": "gilhyun",
   "main": "bootstrap.js",
+  "exports": {
+    ".": "./lib/index.js"
+  },
   "bin": {
     "rune": "bin/rune.js"
   },