@proagentstore/cli 0.1.26 → 0.1.28

package/dist/browser-runner/coding/handlers.js

@@ -0,0 +1,111 @@
+/**
+ * Per-CLI behaviour for the coding runtime.
+ *
+ * Each AI coding CLI renders its TUI differently, so "is it ready for input?",
+ * "is it still working?", and "where does its answer start/end in the pane?" are
+ * CLI-specific. These handlers encapsulate that, ported from the AgentCoder
+ * `bridge/src/agents/handlers/*`. A `generic` shell handler is included so the
+ * runtime (and tests) can drive a plain shell deterministically.
+ */
+/** Shared "find the user's input line, return everything after it up to the next prompt". */
+function sliceAfterInput(captured, userInput, isPromptLine) {
+    const lines = captured.split("\n");
+    const needle = userInput.slice(0, 25);
+    let start = -1;
+    if (needle) {
+        for (let i = lines.length - 1; i >= 0; i--) {
+            if (lines[i].includes(needle)) {
+                start = i;
+                break;
+            }
+        }
+    }
+    if (start === -1)
+        return lines.slice(-200).join("\n").trim();
+    let end = lines.length;
+    for (let i = lines.length - 1; i > start; i--) {
+        if (isPromptLine(lines[i].trim())) {
+            end = i;
+            break;
+        }
+    }
+    return lines.slice(start + 1, end).join("\n").trim();
+}
+export class ClaudeHandler {
+    clientType = "claude";
+    cliCommand = "claude --dangerously-skip-permissions";
+    envVar = "ANTHROPIC_API_KEY";
+    isProcessing(pane) {
+        return pane.includes("ctrl+c to interrupt") || /Working|Thinking|Reading|Searching|Running|Editing|Writing/.test(pane);
+    }
+    isReady(pane) {
+        if (this.isProcessing(pane))
+            return false;
+        const tail = pane.split("\n").slice(-15).join("\n");
+        return (tail.includes("bypass permissions") ||
+            tail.includes("? for shortcuts") ||
+            /❯\s*$/.test(tail) ||
+            /❯ .*↵ send/.test(tail));
+    }
+    extractResponse(captured, userInput) {
+        return sliceAfterInput(captured, userInput, (l) => l === "❯" || l.startsWith("❯ "));
+    }
+    completion() {
+        return { minWait: 1000, stableThreshold: 0, forceCompleteAfter: 5 * 60 * 1000, pollInterval: 500 };
+    }
+}
+export class GeminiHandler {
+    clientType = "gemini";
+    cliCommand = "gemini";
+    envVar = "GEMINI_API_KEY";
+    isProcessing(pane) {
+        return /thinking|processing|generating|working|loading/i.test(pane);
+    }
+    isReady(pane) {
+        const last = pane.split("\n").slice(-1)[0]?.trim() ?? "";
+        const hasPrompt = /[>$]\s*$/.test(last) || /^>/.test(last);
+        return hasPrompt && !this.isProcessing(pane);
+    }
+    extractResponse(captured, userInput) {
+        return sliceAfterInput(captured, userInput, (l) => /^[>$]\s*$/.test(l) || /^[>$]\s+\S/.test(l));
+    }
+    completion() {
+        return { stableThreshold: 1500, forceCompleteAfter: 5 * 60 * 1000, pollInterval: 500 };
+    }
+}
+/** Codex / Grok render close enough to a generic prompt; reuse the shell heuristics. */
+export class GenericHandler {
+    clientType;
+    cliCommand;
+    envVar;
+    constructor(clientType = "generic", cliCommand = "bash", envVar = "") {
+        this.clientType = clientType;
+        this.cliCommand = cliCommand;
+        this.envVar = envVar;
+    }
+    isProcessing(pane) {
+        const last = pane.split("\n").slice(-1)[0]?.trim() ?? "";
+        return /\.\.\.$/.test(last);
+    }
+    isReady(pane) {
+        const last = pane.split("\n").slice(-1)[0]?.trim() ?? "";
+        // A shell prompt ends in $, #, >, or %  (optionally followed by a cursor space).
+        return /[$#>%]\s*$/.test(last) && !this.isProcessing(pane);
+    }
+    extractResponse(captured, userInput) {
+        return sliceAfterInput(captured, userInput, (l) => /[$#>%]\s*$/.test(l));
+    }
+    completion() {
+        return { stableThreshold: 800, forceCompleteAfter: 60 * 1000, pollInterval: 300 };
+    }
+}
+const HANDLERS = {
+    claude: new ClaudeHandler(),
+    gemini: new GeminiHandler(),
+    codex: new GenericHandler("codex", "codex", "OPENAI_API_KEY"),
+    grok: new GenericHandler("grok", "grok", "XAI_API_KEY"),
+    generic: new GenericHandler(),
+};
+export function handlerFor(clientType) {
+    return HANDLERS[clientType] ?? HANDLERS.generic;
+}

package/dist/browser-runner/coding/runtime.js

@@ -0,0 +1,163 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { CodingSession } from "./session.js";
+import { ensureRepo, listSessions as listTmuxSessions, sanitizeSessionName } from "./tmux.js";
+/** Hard cap on a pane returned to the brain/console (matches the worker MAX_PANE_CHARS). */
+const MAX_PANE = 64 * 1024;
+export class CodingRuntime {
+    reposBaseDir;
+    sessions = new Map();
+    /**
+     * Active human handoffs keyed by session id. `resolved` flips when the human
+     * finishes (console "Resume" / submits a value); the brain workflow polls
+     * {@link takeoverStatus} and continues once it does — the tmux analogue of the
+     * browser runtime's handoff-status machinery.
+     */
+    takeovers = new Map();
+    /** Base directory under which repos are cloned (one subdir per repo). */
+    constructor(reposBaseDir = join(homedir(), ".config", "proagentstore", "repos")) {
+        this.reposBaseDir = reposBaseDir;
+    }
+    /** Capabilities advertised to PAGS at registration. */
+    static capabilities() {
+        return ["coding.sessions", "coding.tmux", "human.takeover"];
+    }
+    static taskTypes() {
+        return ["coding.session"];
+    }
+    /** Start (or return the existing) session and report its first snapshot. */
+    start(input) {
+        let session = this.sessions.get(input.sessionId);
+        if (!session) {
+            // Resolve the working dir and ensure the repo is present (clone on first
+            // start). Without this the CLI would launch in a non-existent path.
+            const workDir = input.workDir || join(this.reposBaseDir, sanitizeSessionName(input.repoId));
+            ensureRepo(workDir, { cloneUrl: input.cloneUrl, branch: input.branch, token: input.token });
+            session = new CodingSession({
+                id: input.sessionId,
+                workDir,
+                clientType: input.clientType,
+                env: input.env,
+            });
+            this.sessions.set(input.sessionId, session);
+        }
+        session.start();
+        return this.snapshot(input.sessionId);
+    }
+    /** The pane the brain reasons over + the inferred run state. */
+    snapshot(sessionId) {
+        const session = this.require(sessionId);
+        const alive = session.alive;
+        const pane = alive ? clip(session.snapshot()) : "";
+        return {
+            sessionId,
+            pane,
+            alive,
+            ready: alive ? session.ready : false,
+            runState: alive ? session.runState() : "idle",
+        };
+    }
+    /** Perform one action, then return the fresh snapshot (non-blocking, like browser act). */
+    act(sessionId, action) {
+        const session = this.require(sessionId);
+        switch (action.kind) {
+            case "message":
+                session.input(action.text);
+                break;
+            case "keys":
+                session.key(action.keys);
+                break;
+            case "interrupt":
+                session.interrupt();
+                break;
+            default:
+                throw new Error(`Unknown coding action: ${action.kind}`);
+        }
+        return this.snapshot(sessionId);
+    }
+    /** Tear down a session. */
+    end(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (session) {
+            session.stop();
+            this.sessions.delete(sessionId);
+        }
+        this.takeovers.delete(sessionId);
+        return { ok: true };
+    }
+    list() {
+        return [...this.sessions.entries()].map(([sessionId, s]) => ({
+            sessionId,
+            alive: s.alive,
+            tmuxSession: s.sessionName,
+        }));
+    }
+    // ── Human takeover (the "stuck" handoff) ────────────────────────────────
+    // A text-frame equivalent of the browser takeover: the console shows the live
+    // pane and forwards the human's keystrokes until they Resume.
+    /** Begin a handoff (the brain calls this with why it's pausing). */
+    beginTakeover(sessionId, opts = {}) {
+        this.require(sessionId);
+        this.takeovers.set(sessionId, { reason: opts.reason ?? "stuck", label: opts.label ?? "this step", resolved: false });
+        return this.snapshot(sessionId);
+    }
+    takeoverFrame(sessionId) {
+        return this.snapshot(sessionId);
+    }
+    /** Forward a human keystroke/message during takeover. */
+    takeoverInput(sessionId, value) {
+        const session = this.require(sessionId);
+        if (value.keys)
+            session.key(value.keys);
+        else if (value.text != null)
+            session.input(value.text);
+        return this.snapshot(sessionId);
+    }
+    /** The human finished — mark resolved so the brain workflow can resume. */
+    resolveTakeover(sessionId, value) {
+        const t = this.takeovers.get(sessionId);
+        if (t) {
+            t.resolved = true;
+            t.value = value;
+        }
+        return { ok: true };
+    }
+    /**
+     * Polled by the brain workflow: has the human resolved the handoff? Defaults to
+     * NOT resolved when there's no live entry — if the runner restarted mid-handoff
+     * we must NOT auto-resume (the brain would proceed without the value it was told
+     * to wait for); the workflow's poll loop times out safely instead.
+     */
+    takeoverStatus(sessionId) {
+        const t = this.takeovers.get(sessionId);
+        return { resolved: t?.resolved ?? false, value: t?.value };
+    }
+    endTakeover(sessionId) {
+        this.takeovers.delete(sessionId);
+        return { ok: true };
+    }
+    isUnderTakeover(sessionId) {
+        return this.takeovers.has(sessionId);
+    }
+    /** Stop every session (runner shutdown). */
+    closeAll() {
+        for (const s of this.sessions.values())
+            s.stop();
+        this.sessions.clear();
+        this.takeovers.clear();
+    }
+    /** True if any tmux session this runtime owns is still alive. */
+    hasLiveTmux() {
+        const live = new Set(listTmuxSessions());
+        return [...this.sessions.values()].some((s) => live.has(s.sessionName));
+    }
+    require(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            throw new Error(`No coding session: ${sessionId}`);
+        return session;
+    }
+}
+function clip(pane) {
+    return pane.length > MAX_PANE ? pane.slice(pane.length - MAX_PANE) : pane;
+}

package/dist/browser-runner/coding/session.js

@@ -0,0 +1,149 @@
+import { capturePane, createSession, killSession, paneTarget, sanitizeSessionName, sendKey, sendText, sessionExists, } from "./tmux.js";
+import { handlerFor } from "./handlers.js";
+/**
+ * One AI-coding-CLI session living in a tmux pane.
+ *
+ * This is the coding runtime's analogue of a Playwright `Page`: the unit the
+ * remote brain "sees" (via {@link snapshot}) and "acts on" (via {@link send}),
+ * and the unit a human attaches to during takeover. The brain/hands split and
+ * the streaming-until-idle loop mirror the browser runtime exactly — only the
+ * mechanism (tmux send-keys + capture-pane) differs.
+ */
+export class CodingSession {
+    config;
+    sessionName;
+    target;
+    handler;
+    constructor(config) {
+        this.config = config;
+        this.sessionName = sanitizeSessionName(`pags-${config.clientType}-${config.id}`);
+        this.target = paneTarget(this.sessionName);
+        this.handler = handlerFor(config.clientType);
+    }
+    /** True if the underlying tmux session is alive. */
+    get alive() {
+        return sessionExists(this.sessionName);
+    }
+    /** Launch the CLI inside a fresh tmux session. Idempotent if already alive. */
+    start() {
+        if (this.alive)
+            return;
+        // Launch a shell first so we can export the BYOK env, then exec the CLI.
+        createSession(this.sessionName, this.config.workDir);
+        if (this.config.env) {
+            for (const [k, v] of Object.entries(this.config.env)) {
+                // Use printf-safe assignment; values never reach a shell as code because
+                // we send them as a single literal then press Enter.
+                sendText(this.target, `export ${k}=${JSON.stringify(v)}`);
+                sendKey(this.target, "Enter");
+            }
+        }
+        if (this.handler.cliCommand && this.handler.cliCommand !== "bash") {
+            sendText(this.target, this.handler.cliCommand);
+            sendKey(this.target, "Enter");
+        }
+    }
+    /** The pane content the brain reasons over (the "snapshot"). */
+    snapshot(lines = 200) {
+        return capturePane(this.target, lines);
+    }
+    /** True when the CLI is idle and ready for the next message. */
+    get ready() {
+        return this.handler.isReady(this.snapshot());
+    }
+    /** Send a raw key (Enter, Escape, C-c) — used by takeover and control flows. */
+    key(name) {
+        sendKey(this.target, name);
+    }
+    /**
+     * Submit a message to the CLI without waiting for the reply (text + Enter).
+     * The brain-driven loop calls this, then polls {@link snapshot}/{@link ready}
+     * until idle — the tmux analogue of the browser runtime's non-blocking act.
+     */
+    input(text) {
+        sendText(this.target, text);
+        sendKey(this.target, "Enter");
+    }
+    /** Interrupt the current run (Ctrl-C), e.g. to stop a runaway CLI. */
+    interrupt() {
+        sendKey(this.target, "C-c");
+    }
+    /** Current run-state inferred from the pane: idle / thinking / responding. */
+    runState() {
+        const pane = this.snapshot();
+        if (this.handler.isProcessing(pane)) {
+            return pane.includes("ctrl+c to interrupt") ? "responding" : "thinking";
+        }
+        return this.handler.isReady(pane) ? "idle" : "thinking";
+    }
+    /**
+     * Send a message to the CLI and resolve with its extracted response once the
+     * pane goes idle. Streams intermediate frames through `onStream`.
+     *
+     * The completion heuristic is the same staged one AgentCoder proved against
+     * real CLIs: wait for "processing" to appear, then for the prompt to return
+     * and output to stabilise, with a hard timeout backstop.
+     */
+    async send(message, onStream) {
+        sendText(this.target, message);
+        sendKey(this.target, "Enter");
+        const cfg = this.handler.completion();
+        const startedAt = Date.now();
+        const hardCap = 5 * 60 * 1000;
+        let sawProcessing = false;
+        let lastContent = "";
+        let lastChange = Date.now();
+        let lastEmit = 0;
+        const emitThrottle = 300;
+        while (Date.now() - startedAt < hardCap) {
+            await delay(cfg.pollInterval);
+            if (!this.alive)
+                break;
+            const pane = this.snapshot(5000);
+            const ready = this.handler.isReady(pane);
+            const processing = this.handler.isProcessing(pane);
+            if (onStream) {
+                const partial = this.handler.extractResponse(pane, message);
+                if (partial && partial !== lastContent) {
+                    lastChange = Date.now();
+                    if (Date.now() - lastEmit >= emitThrottle) {
+                        lastContent = partial;
+                        lastEmit = Date.now();
+                        await onStream(partial, false);
+                    }
+                }
+            }
+            if (processing || !ready) {
+                sawProcessing = true;
+                lastChange = Date.now();
+                continue;
+            }
+            const idle = Date.now() - lastChange;
+            const elapsed = Date.now() - startedAt;
+            if (cfg.minWait !== undefined) {
+                if (ready && elapsed > (sawProcessing ? 0 : cfg.minWait))
+                    break;
+            }
+            else {
+                if (ready && sawProcessing && idle >= cfg.stableThreshold)
+                    break;
+                if (ready && elapsed > 2000)
+                    break;
+                if (elapsed >= cfg.forceCompleteAfter)
+                    break;
+            }
+        }
+        const finalPane = this.snapshot(5000);
+        const response = this.handler.extractResponse(finalPane, message);
+        if (onStream)
+            await onStream(response, true);
+        return response;
+    }
+    /** Tear down the tmux session. */
+    stop() {
+        killSession(this.sessionName);
+    }
+}
+function delay(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}

package/dist/browser-runner/coding/tmux.js

@@ -0,0 +1,125 @@
+import { execFileSync } from "node:child_process";
+import { existsSync, mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+/**
+ * Low-level tmux primitives for the coding runtime.
+ *
+ * Ported from the AgentCoder `bridge/src/tmux.ts`, stripped of the Firebase /
+ * logger coupling. These are the "hands" the coding runtime uses to drive a
+ * local AI coding CLI (Claude / Gemini / Codex) running inside a tmux pane —
+ * the tmux analogue of Playwright's page actions in the browser runtime.
+ *
+ * Everything goes through `execFileSync` with an args array so user/agent text
+ * is never shell-interpolated.
+ */
+/** Run tmux with an args array. Throws on non-zero exit. */
+export function tmuxExec(args, timeoutMs = 5000) {
+    return execFileSync("tmux", args, { encoding: "utf8", timeout: timeoutMs });
+}
+/**
+ * The pane target for a session. We address the session by name so tmux routes
+ * to its active pane — robust against user `base-index`/`pane-base-index` config
+ * (a hardcoded `:0.0` breaks when the user sets 1-based indices).
+ */
+export function paneTarget(sessionName) {
+    return sessionName;
+}
+/** Send a named key (Enter, Escape, C-c, …) to a pane. */
+export function sendKey(target, key) {
+    tmuxExec(["send-keys", "-t", target, key]);
+}
+/** Send literal text to a pane (no shell interpolation, no key interpretation). */
+export function sendText(target, text) {
+    tmuxExec(["send-keys", "-t", target, "-l", text]);
+}
+/** True if a tmux session with this name exists. */
+export function sessionExists(sessionName) {
+    try {
+        execFileSync("tmux", ["has-session", "-t", sessionName], { stdio: "pipe" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Create a detached session running an optional command in `workDir`. */
+export function createSession(sessionName, workDir, command) {
+    const args = ["new-session", "-d", "-s", sessionName, "-c", workDir, "-x", "200", "-y", "50"];
+    if (command)
+        args.push(command);
+    execFileSync("tmux", args, { stdio: "ignore" });
+}
+/** Kill a session. Returns false if it did not exist. */
+export function killSession(sessionName) {
+    try {
+        execFileSync("tmux", ["kill-session", "-t", sessionName], { stdio: "pipe" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** List names of all live sessions. */
+export function listSessions() {
+    try {
+        const out = execFileSync("tmux", ["list-sessions", "-F", "#{session_name}"], {
+            encoding: "utf8",
+            stdio: "pipe",
+        });
+        return out.split("\n").map((s) => s.trim()).filter(Boolean);
+    }
+    catch {
+        return [];
+    }
+}
+const ANSI = /\x1B\[[0-?]*[ -/]*[@-~]/g;
+/** Strip ANSI escape codes. */
+export function stripAnsi(s) {
+    return s.replace(ANSI, "");
+}
+/**
+ * Capture the current pane content. `-J` joins wrapped lines so long lines stay
+ * intact; `-S -lines` includes scrollback. Returns ANSI-stripped, trimmed text.
+ */
+export function capturePane(target, lines = 200) {
+    const captured = tmuxExec(["capture-pane", "-p", "-t", target, "-S", `-${lines}`, "-J"]);
+    return stripAnsi(captured).trim();
+}
+/** A safe, collision-resistant tmux session name derived from an arbitrary label. */
+export function sanitizeSessionName(label) {
+    return label.replace(/[^a-zA-Z0-9_-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 60) || "session";
+}
+/**
+ * Ensure a repo is present at `dir`, cloning it from `cloneUrl` if not. Idempotent
+ * — an existing checkout is left alone (no clobber). For private repos a GitHub
+ * App installation token is injected as `x-access-token` into an https URL. The
+ * coding CLI then runs in this directory.
+ *
+ * Returns the absolute working directory. Throws on clone failure so the caller
+ * can surface it (a session can't start without its repo).
+ */
+export function ensureRepo(dir, opts = {}) {
+    // A real checkout (has .git) is reused as-is.
+    if (existsSync(join(dir, ".git")))
+        return dir;
+    if (!opts.cloneUrl) {
+        // No source to clone from — make the directory so tmux can cd into it.
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true });
+        return dir;
+    }
+    // A stale/empty/half-cloned dir (exists but no .git) would make `git clone`
+    // fail on a non-empty target — clear it first so the clone is clean.
+    if (existsSync(dir))
+        rmSync(dir, { recursive: true, force: true });
+    let url = opts.cloneUrl;
+    if (opts.token && /^https:\/\//.test(url)) {
+        url = url.replace(/^https:\/\//, `https://x-access-token:${opts.token}@`);
+    }
+    const args = ["clone", "--depth", "1"];
+    if (opts.branch)
+        args.push("--branch", opts.branch);
+    args.push(url, dir);
+    execFileSync("git", args, { stdio: "pipe", timeout: 180_000 });
+    return dir;
+}

package/dist/browser-runner/index.js

@@ -39,6 +39,8 @@ Endpoints:
   POST /tasks/:id/approve
   POST /tasks/:id/cancel
   GET  /events
+  POST /coding/start | /coding/capture | /coding/act | /coding/end
+  GET  /coding/sessions
 `);
     process.exit(0);
 }

package/dist/browser-runner/runner.js

@@ -8,6 +8,7 @@ import { resolveRealChromeProfileDir, seedProfileCopy } from "./browser-profile.
 import { performBrowserAction } from "./browser-actions.js";
 import { HumanHandoffError, RunnerInputError } from "./errors.js";
 import { RunnerStore } from "./store.js";
+import { CodingRuntime } from "./coding/runtime.js";
 /** True for a plain object. */
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -42,12 +43,15 @@ export class LocalRunner {
     fileAttachArmed = new WeakSet();
     applyResumePath = null;
     store;
+    /** Local tmux coding sessions (the second runtime — AgentCoder port). */
+    coding;
     /** Live human-takeover sessions, keyed by task id (the page is kept alive). */
     takeovers = new Map();
     constructor(config) {
         this.config = config;
         mkdirSync(config.dataDir, { recursive: true });
         this.store = new RunnerStore(config.dataDir);
+        this.coding = new CodingRuntime(join(config.dataDir, "repos"));
         // Tasks paused/running on a previous process are orphaned now — their
         // pages and takeover sessions are gone. Fail them so the board is clean.
         const expired = this.store.expireInFlightTasks();
@@ -61,8 +65,8 @@ export class LocalRunner {
             controlPlane: "pags",
             runtimePlane: "fags",
             runnerRole: "tool-executor",
-            capabilities: CAPABILITIES,
-            taskTypes: ["echo", "browser.open", "job.apply_agent"],
+            capabilities: [...CAPABILITIES, ...CodingRuntime.capabilities()],
+            taskTypes: ["echo", "browser.open", "job.apply_agent", ...CodingRuntime.taskTypes()],
             approvalRequiredFor: [...APPROVAL_REQUIRED_TASKS],
         };
     }
@@ -140,6 +144,7 @@ export class LocalRunner {
         return task;
     }
     async close() {
+        this.coding.closeAll();
         await this.browserContext?.close();
         this.browserContext = null;
     }
@@ -760,7 +765,10 @@ export class LocalRunner {
         const task = this.store.getTask(taskId);
         if (task) {
             const success = outcome === "submitted" || outcome === "ready" || outcome === "expired";
-            task.status = success ? "completed" : "failed";
+            // 'blocked' = the agent stopped and needs the USER (email verification, can't
+            // proceed truthfully) — it's needs-attention, not a failure, so keep it a
+            // distinct status (the console shows it as an active ticket, not buried).
+            task.status = outcome === "blocked" ? "blocked" : success ? "completed" : "failed";
             task.output = { outcome, detail };
             if (!success)
                 task.error = detail || outcome;

package/dist/browser-runner/server.js

@@ -140,6 +140,58 @@ async function route(runner, req, res) {
         await runner.endTakeover(endMatch[1]);
         return json(res, 200, { ok: true });
     }
+    // ── Brain-driven coding control (remote LLM drives a tmux coding CLI) ────
+    // The tmux analogue of the /browser/* surface: start → capture → act → end.
+    if (req.method === "POST" && path === "/coding/start") {
+        const b = await readJson(req);
+        return json(res, 200, runner.coding.start(b));
+    }
+    if (req.method === "POST" && path === "/coding/capture") {
+        const b = await readJson(req);
+        return json(res, 200, runner.coding.snapshot(b.sessionId));
+    }
+    if (req.method === "POST" && path === "/coding/act") {
+        const b = await readJson(req);
+        return json(res, 200, runner.coding.act(b.sessionId, b.action));
+    }
+    if (req.method === "POST" && path === "/coding/end") {
+        const b = await readJson(req);
+        return json(res, 200, runner.coding.end(b.sessionId));
+    }
+    if (req.method === "GET" && path === "/coding/sessions") {
+        return json(res, 200, { sessions: runner.coding.list() });
+    }
+    if (req.method === "POST" && path === "/coding/event") {
+        // Brain progress events — recorded by PAGS, ignored locally. Accept + ack.
+        return json(res, 200, { ok: true });
+    }
+    // ── Human takeover of a coding session (text frames + keystrokes) ───────
+    if (req.method === "POST" && path === "/coding/takeover") {
+        const b = await readJson(req);
+        return json(res, 200, runner.coding.beginTakeover(b.sessionId, { reason: b.reason, label: b.label }));
+    }
+    if (req.method === "POST" && path === "/coding/takeover-status") {
+        const b = await readJson(req);
+        return json(res, 200, runner.coding.takeoverStatus(b.sessionId));
+    }
+    const codingFrameMatch = path.match(/^\/coding\/takeover\/([^/]+)\/frame$/);
+    if (req.method === "GET" && codingFrameMatch) {
+        return json(res, 200, runner.coding.takeoverFrame(codingFrameMatch[1]));
+    }
+    const codingInputMatch = path.match(/^\/coding\/takeover\/([^/]+)\/input$/);
+    if (req.method === "POST" && codingInputMatch) {
+        const b = await readJson(req);
+        return json(res, 200, runner.coding.takeoverInput(codingInputMatch[1], b));
+    }
+    const codingResolveMatch = path.match(/^\/coding\/takeover\/([^/]+)\/resolve$/);
+    if (req.method === "POST" && codingResolveMatch) {
+        const b = await readJson(req);
+        return json(res, 200, runner.coding.resolveTakeover(codingResolveMatch[1], b.value));
+    }
+    const codingEndMatch = path.match(/^\/coding\/takeover\/([^/]+)\/end$/);
+    if (req.method === "POST" && codingEndMatch) {
+        return json(res, 200, runner.coding.endTakeover(codingEndMatch[1]));
+    }
     return json(res, 404, { error: "Not found" });
 }
 function authorize(req, config) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@proagentstore/cli",
-	"version": "0.1.26",
+	"version": "0.1.28",
 	"description": "CLI for creating, publishing, and running ProAgentStore agents",
 	"license": "MIT",
 	"type": "module",