openvisio-agent 0.11.0 → 0.12.0

package/README.md

@@ -62,12 +62,15 @@ Routine messages, triage, introductions, catch-up checks, and ticket movement us
 openvisio-agent watch --name ada                 # run in this terminal
 openvisio-agent watch --name ada --install       # run in the background, start at login
 openvisio-agent watch --name ada --workdir ~/repo  # allow REAL work on a git branch
+openvisio-agent stop --name ada                  # stop service + every ada watcher
 ```
 
 With `--workdir`, the agent gets file + Bash tools scoped to that repo and works on a branch. Guardrails are built in: it never pushes or merges, and destructive shell (`git push`, `rm`, `sudo`, `curl`, publish, PR-merge, …) is denied.
 
 `--install` sets up a background service (launchd on macOS, systemd `--user` on Linux) that runs `watch` and restarts on login. Logs go to `~/.openvisio/<agent>.log` (macOS) or `journalctl --user -u openvisio-<agent>` (Linux).
 
+Do not chase auto-changing watcher PIDs. `openvisio-agent stop --name <agent>` unloads the named background service first, stops every remaining watcher for that exact agent, and clears its stale lock. Running `watch --install` also performs this cleanup before replacing the service.
+
 ## Security
 
 - **No opaque script.** You run a named, versioned npm package you can read here and on [npmjs.com](https://www.npmjs.com/package/openvisio-agent).

package/bin/cli.mjs

@@ -14,7 +14,7 @@ import { mkdirSync, readFileSync, writeFileSync } from 'node:fs'
 import { fileURLToPath } from 'node:url'
 import { dirname, join } from 'node:path'
 import { parseFlags, slugify, stripSlash, exchangeToken, ensureClaude, ensureCodex, writeJson, mcpConfigPath, configPath, chmodSafe, onPath, OV_DIR, fail, ok, info } from '../src/lib.mjs'
-import { runWatch, installService } from '../src/watch.mjs'
+import { runWatch, installService, stopWatchers } from '../src/watch.mjs'
 
 const HERE = dirname(fileURLToPath(import.meta.url))
 const VERSION = (() => { try { return JSON.parse(readFileSync(join(HERE, '..', 'package.json'), 'utf8')).version } catch { return '0.0.0' } })()
@@ -27,6 +27,7 @@ Usage:
   openvisio-agent connect <ovs_code> --host <url> [--name "<agent>"] [--mcp-url <url>] [--agent claude|codex|opencode]
   openvisio-agent connect --backend <url> --key <api-key> --id <identifier> [--name "<agent>"] [--ws <wss-url>] [--mcp-url <url>] [--agent claude|codex|opencode]
   openvisio-agent watch   --name <agent> [--install] [--workspace <dir>] [--chat-only] [--model <m>] [--chat-model <m>] [--debug]
+  openvisio-agent stop    --name <agent>
   openvisio-agent --help | --version
 
 connect
@@ -72,6 +73,11 @@ watch
   setup needed. Use --workspace <dir> to relocate it (e.g. an existing clones folder),
   --chat-only to disable code work, and --install to run in the background on login.
 
+stop
+  Stops the named agent's launchd/systemd service first, then terminates every
+  remaining watcher with that exact --name and clears its stale lock. Use this
+  instead of killing changing PIDs: openvisio-agent stop --name Alex
+
 Docs: https://www.npmjs.com/package/openvisio-agent`
 
 // Register the `openvisio-team` MCP at USER (global) scope so it's available in
@@ -280,6 +286,11 @@ async function main() {
   const rest = parseFlags(argv.slice(1))
   if (cmd === 'connect') return runConnect(rest)
   if (cmd === 'watch') return runWatch(rest)
+  if (cmd === 'stop') {
+    const name = String(rest.flags.name || rest.positional[0] || '')
+    if (!name) fail('Missing agent name.\n  Usage: openvisio-agent stop --name <agent>')
+    return stopWatchers({ slug: slugify(name) })
+  }
   fail(`Unknown command "${cmd}".\n\n${HELP}`)
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openvisio-agent",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "description": "Connect Claude Code, Codex, or OpenCode to an OpenVisio team — MCP tools + optional autonomy — in one command.",
   "type": "module",
   "bin": {

package/src/watch.mjs

@@ -81,7 +81,7 @@ const CODE_CHARTER = [
 
 const CODE_FULL = [
   'THIS CYCLE: call get_marching_orders and poll_inbox to see assigned tickets + mentions, then act on them.',
-  'ACKNOWLEDGE ONCE: for a task assigned to you that you have NOT already acknowledged, post a SINGLE one-line comment_ticket ("On it — picking this up now") before you start. First check the ticket/thread — if you already acknowledged it on an earlier cycle, skip this and just keep working. Then report only when you have the result.',
+  'DO NOT post a promise or pre-work acknowledgement. Start the repository work immediately. Your first task/channel update must contain either a verified result (branch, commit, PR, tests) or a concrete blocker you actually encountered.',
   'For real code work (an assigned ticket, or a mention asking for changes), run the full flow end-to-end:',
   '  1. GET THE CODE: use verified thread/history/recall context first, locate the target repo under your workspace root, and read its AGENTS.md. Reuse an existing clone; clone only if absent. Check `git status` before changing anything and preserve unrelated user work. Update from the remote only when it is safe. Do this yourself; never ask the user for a path you can discover.',
   '  2. BRANCH: git checkout -B agent/<short-task-slug>. NEVER work on, commit to, or push main/master.',
@@ -229,18 +229,13 @@ export async function runWatch({ flags }) {
     const lock = acquireSingleInstance(slug || 'openvisio')
     if (lock.conflict) {
       const watcherName = slug || 'openvisio'
-      const stop = process.platform === 'darwin'
-        ? `launchctl unload ~/Library/LaunchAgents/io.openvisio.${watcherName}.plist`
-        : process.platform === 'win32'
-          ? 'Stop the existing openvisio-agent process in Task Manager.'
-          : `systemctl --user stop openvisio-${watcherName}.service`
       const logs = process.platform === 'darwin'
         ? `tail -f ~/.openvisio/${watcherName}.log`
         : `journalctl --user -u openvisio-${watcherName} -f`
       fail(`Another openvisio-agent watcher for "${watcherName}" is already running (pid ${lock.conflict}).\n` +
         `  Two watchers for the same agent BOTH reply to every mention — that is what causes duplicate/contradicting messages.\n` +
         `  This is usually the auto-restarting background service; killing its PID only makes it restart.\n` +
-        `  To run in this terminal instead, stop the service first:\n    ${stop}\n` +
+        `  Stop the service and every watcher for this agent with:\n    openvisio-agent stop --name ${watcherName}\n` +
         `  Or keep the service and inspect its log:\n    ${logs}\n` +
         `  Refusing to start a second watcher.`)
     }
@@ -348,8 +343,20 @@ function createCodexRunner({ mcpUrl, mcpHeaders, workdir, canCode, maxCycleMs, l
         ...(m ? ['--model', m] : []),
         ...(mcpOverride ? ['-c', mcpOverride] : []),
         full]
-      let child = null, done = false
-      const finish = (o) => { if (done) return; done = true; clearTimeout(timer); resolve(o) }
+      let child = null, done = false, didCode = false, didMessage = false, outputText = '', jsonlBuffer = ''
+      const finish = (o) => { if (done) return; done = true; clearTimeout(timer); resolve({ ...o, didCode, didMessage, outputText }) }
+      const inspectLine = (line) => {
+        const s = line.trim()
+        if (!s) return
+        if (/command_execution|file_change|apply_patch|shell_command|exec_command/i.test(s)) didCode = true
+        if (/post_message|comment_ticket/i.test(s)) didMessage = true
+        try {
+          const event = JSON.parse(s)
+          const item = event.item ?? event
+          if (item?.type === 'agent_message' && typeof item.text === 'string') outputText += ' ' + item.text
+        } catch { /* non-JSON diagnostic */ }
+        if (debug) log('  · ' + s.slice(0, 220))
+      }
       const timer = setTimeout(() => {
         log('codex cycle TIMED OUT after ' + Math.round(maxCycleMs / 1000) + 's — killing')
         try { child && child.kill() } catch { /* gone */ }
@@ -357,15 +364,20 @@ function createCodexRunner({ mcpUrl, mcpHeaders, workdir, canCode, maxCycleMs, l
       }, maxCycleMs)
       log('running codex cycle…' + (m ? ' [' + m + ']' : ''))
       try {
-        child = spawn(bin, args, { cwd, stdio: ['ignore', debug ? 'pipe' : 'ignore', 'inherit'] })
-        if (debug && child.stdout) child.stdout.on('data', (d) => {
-          for (const line of String(d).split('\n')) if (line.trim()) log('  · ' + line.trim().slice(0, 220))
+        // Always inspect Codex JSONL so a successful process exit cannot be
+        // mistaken for completed work. Keep it out of normal logs unless debug.
+        child = spawn(bin, args, { cwd, stdio: ['ignore', 'pipe', 'inherit'] })
+        if (child.stdout) child.stdout.on('data', (d) => {
+          jsonlBuffer += String(d)
+          const lines = jsonlBuffer.split('\n')
+          jsonlBuffer = lines.pop() ?? ''
+          for (const line of lines) inspectLine(line)
         })
       } catch (e) {
         log('codex spawn failed: ' + (e && e.message ? e.message : e) + ' — is Codex installed and signed in? (`npm i -g @openai/codex`, then `codex login`)')
         return finish({ type: 'result', subtype: 'spawn-failed' })
       }
-      child.on('exit', (code) => { log('codex cycle done (' + (code === 0 ? 'ok' : 'exit ' + code) + ')'); finish({ type: 'result', subtype: code === 0 ? 'ok' : 'error' }) })
+      child.on('close', (code) => { inspectLine(jsonlBuffer); jsonlBuffer = ''; log('codex cycle done (' + (code === 0 ? 'ok' : 'exit ' + code) + ')'); finish({ type: 'result', subtype: code === 0 ? 'ok' : 'error' }) })
       child.on('error', (e) => { log('codex error: ' + (e && e.message ? e.message : e)); finish({ type: 'result', subtype: 'error' }) })
     })
   }
@@ -561,7 +573,14 @@ function loopBackendWs({ wsUrl, apiKey, identifier, slug, claude, agent, mcpConf
     emitStatus('working')
     const heartbeat = targets.length ? setInterval(() => emitStatus('working'), 9000) : null
     try {
-      await runCycle(prompt, useModel)
+      const result = await runCycle(prompt, useModel)
+      // Codex can exit successfully after posting only "I'll do it". For coding
+      // cycles, treat that as incomplete and give it one focused recovery turn.
+      // Do not retry a real blocker, which would only create duplicate noise.
+      if (agent === 'codex' && kind === 'full' && result?.subtype === 'ok' && result.didMessage && !result.didCode && !/\b(?:blocked|cannot|can't|missing|need access|permission|unclear)\b/i.test(result.outputText || '')) {
+        log('coding cycle only acknowledged the task; running one completion recovery')
+        await runCycle('You posted an acknowledgement but performed no repository work. Do not post another acknowledgement. Resume the same assigned task now: inspect the workspace, make the required changes, verify them, commit and push an agent/* branch, open the PR, then post exactly one result update with evidence. If a real blocker appears, report that blocker once.', codeModel)
+      }
     } finally {
       if (heartbeat) clearInterval(heartbeat)
       for (const c of targets) { try { handle && handle.sendStatus(c, 'done') } catch { /* noop */ } statusTargets.delete(c) }
@@ -580,7 +599,8 @@ function loopBackendWs({ wsUrl, apiKey, identifier, slug, claude, agent, mcpConf
 
   // Route obvious repository work to the coding lane. Everything else, including
   // chat and board movement, stays on the lightweight coordination model.
-  const needsCode = (value) => /\b(?:code|coding|implement|implementation|fix|bug|debug|refactor|test|tests|build|compile|repository|repo|github|git|branch|commit|pull request|pr|endpoint|api|component|function|class|database|migration|schema|deploy|release|package|npm|typescript|javascript|python|swift|rust|golang|css|html|file|files)\b/i.test(String(value || ''))
+  const needsCode = (value) => /\b(?:code|coding|implement|implementation|create|make|design|fix|bug|debug|refactor|test|tests|build|compile|repository|repo|github|git|branch|commit|pull request|pr|endpoint|api|component|feature|page|screen|ui|function|class|database|migration|schema|deploy|release|package|npm|typescript|javascript|python|swift|rust|golang|css|html|file|files|documentation)\b/i.test(String(value || ''))
+  const coordinationOnly = (value) => /\b(?:move|moving|status|column|assign|reassign|unassign|comment|reply|message|triage|prioriti[sz]e|label|rename|close|reopen)\b/i.test(String(value || '')) && !needsCode(value)
 
   // Engineers change the model under the hood from chat: "/model", "/model sonnet",
   // "use model haiku", "switch model to opus". Returns {report} | {set} | {invalid}.
@@ -633,7 +653,10 @@ function loopBackendWs({ wsUrl, apiKey, identifier, slug, claude, agent, mcpConf
       log('task ' + k.slice(5) + ' #' + (t.id != null ? t.id : '?') + ' (agent ' + agentId + ') “' + (t.title || '') + '”')
       const desc = t.description ? ' — ' + String(t.description).replace(/\s+/g, ' ').slice(0, 400) : ''
       const taskText = [t.title, t.description, t.type, t.kind, Array.isArray(t.labels) ? t.labels.join(' ') : t.labels].filter(Boolean).join(' ')
-      const kind = canCode && needsCode(taskText) ? 'full' : 'coord'
+      // An assigned task is presumed to require execution. Only explicit board or
+      // messaging work stays on the cheap lane; vague verbs such as "create",
+      // "make", or "improve" must not strand a coding task in coordination.
+      const kind = canCode && !coordinationOnly(taskText) ? 'full' : 'coord'
       void drain(kind, `A task was just ${k === 'task:created' ? 'created and assigned' : 'assigned'} to an agent in this workspace: task #${t.id != null ? t.id : '?'}: "${t.title || ''}"${desc} (agent_id ${agentId}). Call get_marching_orders to confirm it is assigned to YOU. If it is yours, acknowledge it once, complete it with the tools appropriate to this ${kind === 'full' ? 'coding' : 'coordination'} lane, move the ticket when appropriate, and report the verified result. If it is not yours, do nothing and stop.`)
     } else if (k === 'agent:mention') {
       const cid = raw.channel_id != null ? raw.channel_id : (raw.channelId != null ? raw.channelId : null)
@@ -843,7 +866,57 @@ function loop({ host, key, slug, claude, agent, mcpConfig, mcpUrl, workdir, mode
 }
 
 // ── background service install (launchd / systemd) ───────────────────────────
+/** Stop the auto-restarting service first, then every orphaned watcher whose
+ *  --name resolves to this exact slug. Never use a broad pkill pattern. */
+export function stopWatchers({ slug, quiet = false }) {
+  const key = slugify(slug || 'openvisio')
+  let serviceStopped = false
+
+  if (process.platform === 'darwin') {
+    const plist = join(homedir(), 'Library', 'LaunchAgents', `io.openvisio.${key}.plist`)
+    if (existsSync(plist)) {
+      const r = spawnSync('launchctl', ['unload', plist], { stdio: 'ignore' })
+      serviceStopped = r.status === 0
+    }
+  } else if (process.platform !== 'win32') {
+    const r = spawnSync('systemctl', ['--user', 'stop', `openvisio-${key}.service`], { stdio: 'ignore' })
+    serviceStopped = r.status === 0
+  }
+
+  const watcherPids = () => {
+    if (process.platform === 'win32') return []
+    const r = spawnSync('ps', ['-axo', 'pid=,command='], { encoding: 'utf8' })
+    if (r.status !== 0) return []
+    const out = []
+    for (const line of String(r.stdout || '').split(/\r?\n/)) {
+      const m = /^\s*(\d+)\s+(.+)$/.exec(line)
+      if (!m) continue
+      const pid = Number(m[1]); const command = m[2]
+      if (pid === process.pid || !/\bopenvisio-agent\b/.test(command) || !/\bwatch\b/.test(command)) continue
+      const name = /(?:^|\s)--name(?:=|\s+)["']?([^"'\s]+)/.exec(command)?.[1]
+      if (name && slugify(name) === key) out.push(pid)
+    }
+    return out
+  }
+
+  const found = watcherPids()
+  for (const pid of found) { try { process.kill(pid, 'SIGTERM') } catch { /* already stopped */ } }
+  if (found.length) Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 600)
+  const stubborn = watcherPids()
+  for (const pid of stubborn) { try { process.kill(pid, 'SIGKILL') } catch { /* already stopped */ } }
+  if (stubborn.length) Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 150)
+
+  const remaining = watcherPids()
+  if (remaining.length) fail(`Could not stop watcher${remaining.length === 1 ? '' : 's'} for "${key}": ${remaining.join(', ')}`)
+  try { unlinkSync(join(OV_DIR, `watch-${key}.lock`)) } catch { /* absent */ }
+  if (!quiet) ok(`Stopped ${found.length} watcher process${found.length === 1 ? '' : 'es'} for "${key}"${serviceStopped ? ' and disabled its background service' : ''}.`)
+  return { stopped: found.length, serviceStopped }
+}
+
 export function installService({ slug, workdir }) {
+  // Replacing a service must also remove manually-started watchers. Otherwise the
+  // new KeepAlive process repeatedly spawns, sees their lock, exits, and respawns.
+  stopWatchers({ slug, quiet: true })
   const binPath = onPath('openvisio-agent')
   if (!binPath || binPath.includes('/_npx/')) {
     info('Installing openvisio-agent globally so the background service has a stable path…')