cheap-agent 1.0.0 → 1.1.1

package/README.md

@@ -31,14 +31,68 @@ But that's exactly what happens every time Opus writes your code: the most expen
 
 **Cheap Agent fixes the org chart.** Opus plans and decides. A model that costs half a cent per task does the typing, in its own copy of your project, and has to prove its work with a test before anything reaches you.
 
+## Why I built this
+
+The idea: get **$200-plan usage out of the $100 Claude plan**, and **$50–70 worth out of the $20 plan**, with a few dollars of DeepSeek doing the typing.
+
+I've met a lot of students, mostly in developing countries, who really want Opus for the hard problems and simply can't afford $100 a month. I wanted to find something that helps them.
+
+This is a small effort from my side. It won't make Opus ten times cheaper. But stretching the plan you already pay for is something, and something is better than nothing.
+
+## Install
+
+**Easiest:** paste this into Claude Code. It asks what you want, then gives you one command to run.
+
+```text
+Set up Cheap Agent (npm: cheap-agent) for me.
+1. Ask me: which provider (OpenRouter recommended, DeepSeek or OpenCode Go), and which
+   models (balanced is the default; cheapest, strongest, or my own provider/model).
+2. Check that node is 20+ and the claude CLI is installed.
+3. If I picked my own model, save {"models":{"implement":"<model>"}} in
+   ~/.config/cheapag/config.json, keeping what else is there.
+4. Give me the command to run in my terminal: npx cheap-agent login --preset <my choice,
+   or custom>, and which number to pick for my provider (1 OpenCode Go, 2 OpenRouter,
+   3 DeepSeek). I run it and type my API key there. Never ask for my key.
+5. When I say done, check `claude mcp list` shows cheapag, then tell me to run
+   /cheapag:allow in a new Claude Code session in my project.
+```
+
+**Or do it yourself:**
+
+```bash
+npx cheap-agent
+```
+
+Pick a provider (**OpenRouter** if unsure), press Enter for the recommended models, paste your API key. It checks the key works, then adds itself to Claude Code for every project.
+
+Then, in each project, once:
+
+```
+/cheapag:allow
+```
+
+**That's it.** Ask Claude for changes like you always do.
+
+**You need:**
+- [Claude Code](https://claude.com/claude-code)
+- [Node.js](https://nodejs.org) 20+
+- An API key with a few dollars on it from [OpenRouter](https://openrouter.ai/keys), [DeepSeek](https://platform.deepseek.com) or [OpenCode Go](https://opencode.ai)
+
+A few dollars lasts hundreds of tasks. It runs on macOS and Linux.
+
+**Windows (beta):** tested in CI, not yet by a Windows user. You also need [Git for Windows](https://git-scm.com/downloads/win) (Git Bash). Known so far:
+- The very first job can take about 2 minutes while the cheap model's engine (OpenCode) sets itself up. Later jobs start in seconds.
+- If that engine crashes mid-session, Cheap Agent starts a new one, but the crashed copy can stay running (`opencode.exe` in Task Manager) until you end it or restart.
+- The cheap model can't read your dependency folders (like `node_modules`) inside its copy of the project. Your tests still run normally.
+
 ## The numbers
 
+Tested on [SWE-bench Verified](https://www.swebench.com): real bugs from real open-source projects, graded by the official harness. Same prompts in Claude Code with Opus 5.5, with and without Cheap Agent.
+
 <p align="center">
   <img src="assets/chart.svg" width="880" alt="Opus tokens, Claude Code alone versus with Cheap Agent. Adding a feature: 154k vs 57k, 63% less, both pass all tests. 7 everyday bug fixes: 1.6M vs 655k, 59% less, 7 of 7 solved by both. 9 of the hardest bugs: 3.0M vs 1.0M, 67% less, 5 of 9 solved vs 7 of 9, with a Sonnet helper doing the leftovers.">
 </p>
 
-Measured in Claude Code with Opus 5.5: the same agent and the same prompts, with and without Cheap Agent. The bug fixes are real issues from real open-source projects ([SWE-bench Verified](https://www.swebench.com)), graded by the official harness.
-
 **What I won't hide:**
 - On the very hardest bugs it solved 5 of 9 where plain Opus solved 7.
 - On tiny jobs (a few lines, or a whole small app from nothing), Opus is already quick, so there's nothing to save.
@@ -56,7 +110,11 @@ Cheap Agent shines on the work in between: real features and real fixes in real
 | Who wrote the code | Opus | a cheap model, for **$0.005** |
 | Tests | 33 passing | **38 passing** |
 
-Opus read the request, wrote one task and read a ten-line result. That's all it did. The cheap model explored the code, wrote a test that failed, made it pass, and handed back a change that works. Same feature, a third of the Opus bill.
+Opus wrote one task. The cheap model did the rest, tests included.
+
+## Built with itself
+
+Native Windows support (36 files, +753/−278 lines) was built with Cheap Agent. Claude found the problems and wrote the plans. The cheap model wrote the code in 30 jobs for **$0.29 in total**, Sonnet helpers finished what it couldn't and read OpenCode's source to find the two Windows-only bugs, and the full test suite now passes on Linux and Windows.
 
 ## How it works
 
@@ -68,29 +126,6 @@ Opus read the request, wrote one task and read a ten-line result. That's all it
 - **Your project stays clean.** Work happens in a private copy (a git worktree). Only passing work lands, uncommitted, so you review the diff like any other.
 - **Opus stays in charge,** but it's held to it: Cheap Agent's hooks stop Opus from quietly redoing work that already passed, or doing a failed step itself when Sonnet can.
 
-## Install
-
-```bash
-npx cheap-agent
-```
-
-Pick a provider (**OpenRouter** if unsure), press Enter for the recommended models, paste your API key. It checks the key works, then adds itself to Claude Code for every project.
-
-Then, in each project, once:
-
-```
-/cheapag:allow
-```
-
-**That's it.** Ask Claude for changes like you always do.
-
-**You need:**
-- [Claude Code](https://claude.com/claude-code)
-- [Node.js](https://nodejs.org) 20+
-- An API key with a few dollars on it from [OpenRouter](https://openrouter.ai/keys), [DeepSeek](https://platform.deepseek.com) or [OpenCode Go](https://opencode.ai)
-
-A few dollars lasts hundreds of tasks. It runs on macOS and Linux; on Windows, use WSL.
-
 ## Commands
 
 | Command | What it does |

package/dist/allow.js

@@ -1,6 +1,5 @@
 import { consentGate, describe, writeConsent } from "./consent.js";
 import { detectProvider, LOGIN_COMMAND, providerLabel, redact } from "./credentials.js";
-import { isSupported, UNSUPPORTED_REASON } from "./platform.js";
 import { modelName, routeModels } from "./routing.js";
 import { projectRoot } from "./workspace.js";
 const USAGE = "usage: cheapag allow [--zdr-only | --models <provider/model,…>]";
@@ -11,10 +10,6 @@ const USAGE = "usage: cheapag allow [--zdr-only | --models <provider/model,…>]
  */
 export function allow(args) {
     const out = (line) => process.stdout.write(redact(line) + "\n");
-    if (!isSupported()) {
-        out(`✗ ${UNSUPPORTED_REASON}`);
-        return 1;
-    }
     let consent;
     if (!args.length)
         consent = { mode: "all" };

package/dist/cleanup.js

@@ -3,7 +3,7 @@ import { join } from "node:path";
 import { loadConfig } from "./config.js";
 import { redact } from "./credentials.js";
 import { recoverJobs } from "./jobs.js";
-import { isAlive, isSupported, removeLink, UNSUPPORTED_REASON } from "./platform.js";
+import { isAlive, removeLink } from "./platform.js";
 import { git, projectRoot } from "./workspace.js";
 /**
  * Cleanup (spec: Concurrency, platform, cleanup; A20), part of the Workspace module: at server start and on
@@ -119,10 +119,6 @@ export function cleanProject(cwd, all = false) {
 /** `cheapag clean [--all]`: non-interactive, so the plugin's `/cheapag:clean` can wrap it; prints what went and what stayed. */
 export function clean(args) {
     const out = (line) => process.stdout.write(redact(line) + "\n");
-    if (!isSupported()) {
-        out(`✗ ${UNSUPPORTED_REASON}`);
-        return 1;
-    }
     if (args.length > 1 || (args.length && args[0] !== "--all")) {
         out("✗ usage: cheapag clean [--all]   (--all: remove everything not in flight)");
         return 1;

package/dist/hook.js

@@ -1,5 +1,5 @@
 import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { join, resolve } from "node:path";
+import { join, resolve, sep } from "node:path";
 import { loadConfig } from "./config.js";
 import { projectRoot } from "./workspace.js";
 const USAGE = "usage: cheapag hook [on | off]";
@@ -221,7 +221,7 @@ function check(input) {
     writeFileSync(state, JSON.stringify(turn));
 }
 /** Plans live in .plan/ and are how Claude delegates, so the guard never blocks them. */
-const isPlan = (root, file) => file.startsWith(join(root, ".plan") + "/");
+const isPlan = (root, file) => file.startsWith(join(root, ".plan") + sep);
 /** A Bash command is denied when it writes a file inside the repo (any size: the lines can't be counted), unless the file is a plan. */
 function bashCheck(cwd, command) {
     const root = projectRoot(cwd);
@@ -232,7 +232,7 @@ function bashCheck(cwd, command) {
         for (const m of command.matchAll(re))
             if (m.groups?.path)
                 targets.push(m.groups.path);
-    const inRepo = (p) => { const abs = resolve(cwd, p); return abs.startsWith(root + "/") && !isPlan(root, abs); };
+    const inRepo = (p) => { const abs = resolve(cwd, p); return abs.startsWith(root + sep) && !isPlan(root, abs); };
     const written = targets.filter((p) => p !== "/dev/null" && inRepo(p));
     if (written.length)
         return `Bash writing ${written[0]}: ${REDIRECT}`;

package/dist/install.js

@@ -1,9 +1,9 @@
-import { spawnSync } from "node:child_process";
 import { cpSync, mkdirSync, readdirSync, readFileSync, realpathSync, rmSync, writeFileSync } from "node:fs";
 import { createRequire } from "node:module";
 import { delimiter, dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { userConfigFile } from "./config.js";
+import { normalisePath, runCli, which } from "./platform.js";
 /**
  * The Claude Code plugin (hooks and slash commands), installed by setup (ticket 31). It is generated from this package's
  * own plugin/ so it always matches the installed version, needs no public marketplace, and leaves out .mcp.json (setup
@@ -17,22 +17,64 @@ export const MARKETPLACE = "cheapag";
 /** Where setup keeps the launcher and the generated marketplace: next to the user config. */
 export const installPaths = () => {
     const home = dirname(userConfigFile());
-    return { launcher: join(home, "bin", "cheapag"), marketplace: join(home, "marketplace") };
+    return { launcher: join(home, "bin", "cheapag.cjs"), marketplace: join(home, "marketplace") };
 };
+/**
+ * The launcher every hook and command runs as `node <launcher> <args>`. Windows has no /bin/sh, so one CommonJS file
+ * runs on every platform: it gates the guard hook (exit 0 unless the repo opted in), then runs this install when it is
+ * still there, else the pinned npx.
+ */
+const launcherScript = (entry) => `// cheapag: gates the guard hook, runs this install, else the fallback npx -y cheap-agent@${version}
+"use strict";
+const { execFileSync, spawnSync } = require("node:child_process");
+const { existsSync } = require("node:fs");
+const { join } = require("node:path");
+const { pathToFileURL } = require("node:url");
+const entry = ${JSON.stringify(entry)};
+if (process.argv[2] === "hook" && process.argv[3] === "guard") {
+  let root;
+  try {
+    root = execFileSync("git", ["rev-parse", "--show-toplevel"], { stdio: ["ignore", "pipe", "ignore"] }).toString().trim();
+  } catch {
+    process.exit(0);
+  }
+  if (!existsSync(join(root, ".cheapag", "hook.json")) && !existsSync(join(root, ".cheapag", "hook", "takeover"))) process.exit(0);
+}
+if (existsSync(entry)) {
+  process.argv[1] = entry;
+  import(pathToFileURL(entry).href);
+} else {
+  const r = spawnSync("npx", ["-y", "cheap-agent@${version}", ...process.argv.slice(2)], { stdio: "inherit", shell: process.platform === "win32" });
+  process.exit(r.status ?? 1);
+}
+`;
 /** Writes the launcher and the plugin's marketplace; returns the marketplace directory. */
-export function writePlugin(entry, node) {
+export function writePlugin(entry, _node, platform = process.platform) {
     const { launcher, marketplace } = installPaths();
     mkdirSync(dirname(launcher), { recursive: true });
-    const q = (s) => `'${s.replace(/'/g, `'\\''`)}'`;
-    writeFileSync(launcher, `#!/bin/sh\n# Cheap Agent's hooks and commands run through here: this install, or npx once it is gone\n[ -f ${q(entry)} ] && exec ${q(node)} ${q(entry)} "$@"\nexec ${NPX} "$@"\n`, { mode: 0o755 });
+    writeFileSync(launcher, launcherScript(entry));
+    // Windows commands run in Git Bash or PowerShell, so they take double quotes and forward slashes; POSIX keeps single quotes
+    const ref = platform === "win32" ? `node "${normalisePath(launcher)}"` : `node '${launcher}'`;
     rmSync(marketplace, { recursive: true, force: true });
     const plugin = join(marketplace, "cheapag");
     cpSync(PLUGIN_SRC, plugin, { recursive: true });
     rmSync(join(plugin, ".mcp.json"), { force: true });
-    // shortcut: a home directory with a space breaks the unquoted launcher path in hooks and allowed-tools; quote it per context if anyone hits that
-    const files = [join(plugin, "hooks", "hooks.json"), ...readdirSync(join(plugin, "skills")).map((s) => join(plugin, "skills", s, "SKILL.md"))];
-    for (const f of files)
-        writeFileSync(f, readFileSync(f, "utf8").replaceAll(NPX, launcher));
+    const skills = readdirSync(join(plugin, "skills")).map((s) => join(plugin, "skills", s, "SKILL.md"));
+    for (const f of skills)
+        writeFileSync(f, readFileSync(f, "utf8").replaceAll(NPX, ref));
+    const hooksFile = join(plugin, "hooks", "hooks.json");
+    if (platform === "win32") {
+        // rewrite the commands as JSON: a raw replace would put unescaped double quotes inside the strings; no sh prefix, since the launcher gates and exits 0
+        const json = JSON.parse(readFileSync(hooksFile, "utf8"));
+        const command = (action) => `${ref} hook ${action}`;
+        json.hooks.PreToolUse[0].hooks[0].command = command("guard");
+        json.hooks.PostToolUse[0].hooks[0].command = command("result");
+        json.hooks.SessionStart[0].hooks[0].command = command("context");
+        writeFileSync(hooksFile, JSON.stringify(json, null, 2) + "\n");
+    }
+    else {
+        writeFileSync(hooksFile, readFileSync(hooksFile, "utf8").replaceAll(NPX, ref));
+    }
     mkdirSync(join(marketplace, ".claude-plugin"), { recursive: true });
     writeFileSync(join(marketplace, ".claude-plugin", "marketplace.json"), JSON.stringify({
         name: MARKETPLACE, owner: { name: "muaaz9329" }, description: "Cheap Agent, generated by its setup from the installed package",
@@ -43,16 +85,16 @@ export function writePlugin(entry, node) {
 /** Generates the plugin and adds it to Claude Code (or updates it); prints the manual commands when a step fails. */
 export function installPlugin(out) {
     const marketplace = writePlugin(realpathSync(process.argv[1]), stableNode());
-    const claude = (...args) => spawnSync("claude", ["plugin", ...args], { encoding: "utf8" });
-    const listed = (args, name) => (claude(...args).stdout ?? "").includes(name);
+    const claude = (...args) => runCli("claude", ["plugin", ...args], { encoding: "utf8" });
+    const listed = (args, name) => (claude(...args)?.stdout ?? "").includes(name);
     const steps = [
         listed(["marketplace", "list"], MARKETPLACE) ? ["marketplace", "update", MARKETPLACE] : ["marketplace", "add", marketplace],
         listed(["list"], `cheapag@${MARKETPLACE}`) ? ["update", `cheapag@${MARKETPLACE}`] : ["install", `cheapag@${MARKETPLACE}`],
     ];
     for (const step of steps) {
         const r = claude(...step);
-        if (r.status !== 0) {
-            out(`✗ claude plugin ${step.join(" ")} failed (${(r.stderr || r.stdout || "").trim().split("\n")[0]}). Run these yourself:`);
+        if (!r || r.status !== 0) {
+            out(`✗ claude plugin ${step.join(" ")} failed (${((r?.stderr || r?.stdout) ?? "").trim().split("\n")[0]}). Run these yourself:`);
             out(`  claude plugin marketplace add ${marketplace}\n  claude plugin install cheapag@${MARKETPLACE}`);
             return false;
         }
@@ -64,11 +106,14 @@ export function installPlugin(out) {
 export function stableNode() {
     const self = realpathSync(process.execPath);
     for (const dir of (process.env.PATH ?? "").split(delimiter)) {
+        if (!dir)
+            continue;
+        const candidate = which("node", process.platform, { PATH: dir, PATHEXT: process.env.PATHEXT });
         try {
-            if (dir && realpathSync(join(dir, "node")) === self)
-                return join(dir, "node");
+            if (candidate && realpathSync(candidate) === self)
+                return candidate;
         }
-        catch { } // no node in this PATH entry
+        catch { } // vanished between lookup and realpath
     }
     return process.execPath;
 }

package/dist/jobs.js

@@ -10,7 +10,7 @@ import { projectScripts, workerRuleset } from "./permissions.js";
 import { consentGate } from "./consent.js";
 import { chain, DIFFICULTIES, escalationSkip, modelName, recordSpend, runRouted, tierModel, usedBalance } from "./routing.js";
 import { errorTail, runVerify, sameFailure, verifyCommands } from "./verify.js";
-import { finishReport, openSession } from "./worker.js";
+import { finishReport, openSession, releaseDirectory } from "./worker.js";
 import { conflictPaths, createWorktree, git, jobWorktree, land, leftoverMarkers, operationInProgress, projectRoot, reapply, removeWorktree, withLock, worktreeDiff, } from "./workspace.js";
 import { isAlive, normalisePath } from "./platform.js";
 /** Jobs: runs each group of plan steps as one job, start to landing, under per-job caps (several groups make a batch); lists, shows and cancels jobs. */
@@ -343,6 +343,7 @@ function runGroup(g) {
     const redo = async (patch, clash, work) => {
         redone = 1;
         write("conflict.patch", patch); // log copy of the change that clashed
+        await releaseDirectory(worktree.path); // release before the path is removed, then recreated
         removeWorktree(root, worktree);
         // the same path, so the session's directory stays valid
         worktree = createWorktree(root, job, config.link_dirs);
@@ -369,6 +370,7 @@ function runGroup(g) {
             landing = true;
             pauseClock();
             if (!(await land(root, job, diff.patch, diff.changed.map((c) => c.path)))) {
+                await releaseDirectory(worktree.path);
                 removeWorktree(root, worktree);
                 return;
             }
@@ -508,8 +510,10 @@ function runGroup(g) {
                     landing = true; // from here on, caps and cancel no longer apply (until a redo works again)
                     pauseClock();
                     const clash = await land(root, job, diff.patch, diff.changed.map((c) => c.path));
-                    if (!clash)
+                    if (!clash) {
+                        await releaseDirectory(worktree.path);
                         removeWorktree(root, worktree);
+                    }
                     else
                         await redo(diff.patch, clash, work);
                 }
@@ -1025,6 +1029,7 @@ async function landOne(root, config, id, action) {
         writeWhole(join(dir, "result.txt"), redact(text + "\n"));
     };
     if (action === "discard") {
+        await releaseDirectory(worktree.path); // release before the worktree is removed
         removeWorktree(root, worktree); // dependency links are unlinked first
         save({ discarded: true });
         return `OK ${id} discarded`;
@@ -1038,6 +1043,7 @@ async function landOne(root, config, id, action) {
         const files = conflictPaths(clash);
         throw new Error(`landing conflict${files.length ? ` in ${files.join(", ")}` : ""}, working tree untouched; discard it, or fix the overlap and delegate again`);
     }
+    await releaseDirectory(worktree.path); // release before the worktree is removed
     removeWorktree(root, worktree);
     save({ landed: true, changed: diff.changed });
     const add = diff.changed.reduce((n, c) => n + c.add, 0);
@@ -1156,8 +1162,9 @@ function reviewRanges(review, base) {
         .slice(0, 5);
 }
 const inside = (root, path) => {
-    const rel = relative(root, path);
-    return rel !== "" && !rel.startsWith(`..${"/"}`) && rel !== ".." && !isAbsolute(rel);
+    // normalised: relative() gives "..\\x" on Windows
+    const rel = normalisePath(relative(root, path));
+    return rel !== "" && !rel.startsWith("../") && rel !== ".." && !isAbsolute(rel);
 };
 /**
  * Writes a file whole: to a temporary name, then renamed into place. Records are rewritten on every turn while other

package/dist/login.js

@@ -2,12 +2,12 @@ import { spawnSync } from "node:child_process";
 import { existsSync, mkdirSync, mkdtempSync, readFileSync, realpathSync, rmSync, writeFileSync } from "node:fs";
 import { createRequire } from "node:module";
 import { tmpdir } from "node:os";
-import { dirname, join } from "node:path";
+import { dirname, join, sep } from "node:path";
 import { createInterface } from "node:readline/promises";
 import { loadConfig, userConfigFile } from "./config.js";
 import { detectProvider, LOGIN_COMMAND as LOGIN, PROVIDERS, providerLabel as label, redact, savedProviders } from "./credentials.js";
 import { ensureOpencode, opencodeBinary, stopOpencode } from "./opencode.js";
-import { isSupported, UNSUPPORTED_REASON } from "./platform.js";
+import { runCli } from "./platform.js";
 import { installPlugin, stableNode } from "./install.js";
 import { fullRoute, modelName, presetOf, PRESET_NAMES, PRESETS } from "./routing.js";
 import { runSession } from "./worker.js";
@@ -22,10 +22,6 @@ const CHOICES = [...PRESET_NAMES, "custom"];
 const isChoice = (s) => CHOICES.includes(s);
 export async function login(args = []) {
     const out = (line = "") => process.stdout.write(redact(line) + "\n");
-    if (!isSupported()) {
-        out(`✗ ${UNSUPPORTED_REASON}`);
-        return 1;
-    }
     const flag = args.length === 2 && args[0] === "--preset" ? args[1] : undefined;
     if (args.length && flag === undefined) {
         out(`✗ usage: cheapag login [--preset ${CHOICES.join("|")}]`);
@@ -175,8 +171,8 @@ function explain(message, model) {
 async function register(out) {
     const command = serverCommand();
     const manual = `claude mcp add -s user cheapag -- ${command.map(quote).join(" ")}`;
-    const existing = spawnSync("claude", ["mcp", "get", "cheapag"], { encoding: "utf8" });
-    if (existing.error) {
+    const existing = runCli("claude", ["mcp", "get", "cheapag"], { encoding: "utf8" });
+    if (!existing) {
         out(`Claude Code's CLI was not found. To add cheapag for all your projects, run:\n  ${manual}`);
         return;
     }
@@ -191,9 +187,9 @@ async function register(out) {
         out(`Not registered. To add it later, run:\n  ${manual}`);
         return;
     }
-    const added = spawnSync("claude", ["mcp", "add", "-s", "user", "cheapag", "--", ...command], { encoding: "utf8" });
-    if (added.status !== 0) {
-        out(`✗ claude mcp add failed (${(added.stderr || added.stdout).trim().split("\n")[0]}). Run it yourself:\n  ${manual}`);
+    const added = runCli("claude", ["mcp", "add", "-s", "user", "cheapag", "--", ...command], { encoding: "utf8" });
+    if (!added || added.status !== 0) {
+        out(`✗ claude mcp add failed (${((added?.stderr || added?.stdout) ?? "").trim().split("\n")[0]}). Run it yourself:\n  ${manual}`);
         return;
     }
     out("✓ Added cheapag to Claude Code for all your projects");
@@ -208,9 +204,10 @@ function finish(out, plugin) {
 /** How Claude Code should start this installed package: npx when run from npx's cache, else this exact file. */
 function serverCommand() {
     const entry = realpathSync(process.argv[1]);
-    return entry.includes("/_npx/") ? ["npx", "-y", `cheap-agent@${version}`] : [stableNode(), entry];
+    return entry.split(sep).includes("_npx") ? ["npx", "-y", `cheap-agent@${version}`] : [stableNode(), entry];
 }
-const quote = (arg) => (/^[\w@%+=:,./-]+$/.test(arg) ? arg : `'${arg.replace(/'/g, `'\\''`)}'`);
+// double quotes on Windows: cmd and PowerShell don't treat single quotes as quoting
+const quote = (arg) => /^[\w@%+=:,./-]+$/.test(arg) ? arg : process.platform === "win32" ? `"${arg.replace(/"/g, '\\"')}"` : `'${arg.replace(/'/g, `'\\''`)}'`;
 /** One question on a fresh readline, closed before anything else (OpenCode's login) reads the terminal. */
 async function ask(question) {
     const rl = createInterface({ input: process.stdin, output: process.stdout });

package/dist/opencode.js

@@ -5,7 +5,7 @@ import { createRequire } from "node:module";
 import { arch } from "node:os";
 import { dirname, join } from "node:path";
 import { baselinePermission } from "./permissions.js";
-import { killProcessGroup, opencodePlatform } from "./platform.js";
+import { gitBash, killProcessGroup, opencodePlatform } from "./platform.js";
 import { fullRoute, modelName, routeModels } from "./routing.js";
 const require = createRequire(import.meta.url);
 export const OPENCODE_PIN = require("opencode-ai/package.json").version;
@@ -63,22 +63,21 @@ answer:
 \`\`\`
 `;
 // Runs inside OpenCode (Bun). Its input is captured from the event stream, so it only has to exist and validate.
-export const FINISH_TOOL_SOURCE = `import { tool } from "@opencode-ai/plugin";
-
-export default tool({
+// It imports nothing (OpenCode accepts a plain { description, args, execute } with JSON Schema args), so OpenCode has nothing to install.
+export const FINISH_TOOL_SOURCE = `export default {
   description: "Report the step as done. Call exactly once, as your last action.",
   args: {
-    summary: tool.schema.string().max(160).describe("What you did, at most 160 characters"),
-    risks: tool.schema.array(tool.schema.string()).describe("Assumptions, unverified conditions, edits outside files:"),
-    review: tool.schema.array(tool.schema.string()).max(5).describe("Ranges worth a human look, as path:start-end"),
-    missing: tool.schema.array(tool.schema.string()).describe("Anything the step asked for that you did not do"),
-    repro: tool.schema.string().describe("The exact command that runs your reproduction test (fails on the original code, passes now); 'none: <why>' if you could not reproduce the problem; 'n/a' if the step is not a fix"),
-    disagree: tool.schema.string().describe("Where the step's spec and the Source you were given disagree (direction, order, value, approach), or 'none'"),
+    summary: { type: "string", maxLength: 160, description: "What you did, at most 160 characters" },
+    risks: { type: "array", items: { type: "string" }, description: "Assumptions, unverified conditions, edits outside files:" },
+    review: { type: "array", items: { type: "string" }, maxItems: 5, description: "Ranges worth a human look, as path:start-end" },
+    missing: { type: "array", items: { type: "string" }, description: "Anything the step asked for that you did not do" },
+    repro: { type: "string", description: "The exact command that runs your reproduction test (fails on the original code, passes now); 'none: <why>' if you could not reproduce the problem; 'n/a' if the step is not a fix" },
+    disagree: { type: "string", description: "Where the step's spec and the Source you were given disagree (direction, order, value, approach), or 'none'" },
   },
   async execute() {
     return "Reported. Stop now.";
   },
-});
+};
 `;
 /**
  * Runs inside OpenCode (Bun), for every session: grep returns matching lines, and the read deny on .env* does not
@@ -112,6 +111,9 @@ export function writeConfigDir(dir, config) {
     mkdirSync(join(dir, "agents"), { recursive: true });
     mkdirSync(join(dir, "tools"), { recursive: true });
     mkdirSync(join(dir, "plugins"), { recursive: true });
+    // node_modules + package-lock.json listing @opencode-ai/plugin make OpenCode skip its npm install of it into this dir (core/src/npm.ts); neither generated file imports it
+    mkdirSync(join(dir, "node_modules"), { recursive: true });
+    writeFileSync(join(dir, "package-lock.json"), JSON.stringify({ name: "cheapag-opencode", lockfileVersion: 3, requires: true, packages: { "": { dependencies: { "@opencode-ai/plugin": OPENCODE_PIN } } } }));
     writeFileSync(join(dir, "agents", "cheapag-worker.md"), WORKER_PROMPT);
     writeFileSync(join(dir, "agents", "cheapag-research.md"), RESEARCH_PROMPT);
     writeFileSync(join(dir, "tools", "finish.ts"), FINISH_TOOL_SOURCE);
@@ -153,6 +155,15 @@ export function holdOpencode() {
         held = false;
     };
 }
+/** The running server, if one is up; never boots one. */
+export async function runningOpencode() {
+    try {
+        return await started;
+    }
+    catch {
+        return undefined; // a failed boot leaves nothing to reach
+    }
+}
 export function ensureOpencode(provider, projectDir = process.cwd(), route) {
     const config = opencodeConfig(provider, route ?? fullRoute(provider.provider));
     if (started && route && booted !== config) {
@@ -190,16 +201,23 @@ async function boot(projectDir, config) {
     return { url, password, version };
 }
 function spawnServer(configDir, password) {
+    // on Windows point the worker at Git Bash, so it runs and parses its commands as bash, like the rest of cheapag
+    const bash = process.platform === "win32" ? gitBash() : undefined;
     return new Promise((resolve, reject) => {
         // detached: its own process group, so stopOpencode() also takes down anything it spawned
         const proc = spawn(opencodeBinary(), ["serve", "--hostname", "127.0.0.1", "--port", "0"], {
             detached: true,
+            // a detached console child would open a window on Windows
+            windowsHide: true,
             stdio: ["ignore", "pipe", "pipe"],
             env: {
                 ...process.env,
                 OPENCODE_SERVER_PASSWORD: password,
                 OPENCODE_CONFIG_DIR: configDir,
                 OPENCODE_DISABLE_PROJECT_CONFIG: "1",
+                // OpenCode watches each session dir's .git; cheapag uses none of its events, and on Windows the open handle blocks removing the worktree
+                OPENCODE_EXPERIMENTAL_DISABLE_FILEWATCHER: "1",
+                ...(bash ? { SHELL: bash } : {}),
                 // the server-wide baseline; each worker session also carries the full ruleset, which wins (src/permissions.ts)
                 OPENCODE_PERMISSION: JSON.stringify(baselinePermission()),
             },

package/dist/platform.js

@@ -1,16 +1,13 @@
-import { lstatSync, symlinkSync, unlinkSync } from "node:fs";
-import { sep } from "node:path";
+import { spawnSync } from "node:child_process";
+import { existsSync, lstatSync, readdirSync, symlinkSync, unlinkSync } from "node:fs";
+import { delimiter, dirname, join, sep } from "node:path";
 /**
- * Platform: everything OS-specific lives here (spec A18). POSIX only in v1; a Windows port swaps in directory
- * junctions, long-path handling and `taskkill /T` behind these same functions.
+ * Platform: everything OS-specific lives here (spec A18). Windows is supported through junctions, taskkill and
+ * PATHEXT lookup here; callers stay platform-free.
  */
-export const UNSUPPORTED_REASON = "Windows not supported yet; use WSL";
-export const UNSUPPORTED = `FAIL reason: ${UNSUPPORTED_REASON}`;
-/** macOS and Linux (WSL reports linux) are supported; native Windows is not yet. */
-export const isSupported = (platform = process.platform) => platform !== "win32";
-/** Links a dependency directory into a worktree. */
+/** Links a dependency directory into a worktree. Junctions need no privilege on Windows, unlike directory symlinks. */
 export function link(target, path) {
-    symlinkSync(target, path, "dir");
+    symlinkSync(target, path, process.platform === "win32" ? "junction" : "dir");
 }
 /** Removes a link made by `link`, never what it points to; does nothing if `path` is not a link. */
 export function removeLink(path) {
@@ -43,6 +40,11 @@ export function opencodePlatform() {
 export function killProcessGroup(pid, signal = "SIGTERM") {
     if (!pid)
         return;
+    if (process.platform === "win32") {
+        // no process groups on Windows; taskkill walks the tree instead and ignores the signal
+        spawnSync("taskkill", ["/pid", String(pid), "/T", "/F"], { stdio: "ignore", windowsHide: true });
+        return;
+    }
     try {
         process.kill(-pid, signal);
     }
@@ -50,3 +52,61 @@ export function killProcessGroup(pid, signal = "SIGTERM") {
         // already gone
     }
 }
+/** The first executable named `name` on `env`'s PATH, or undefined. On Windows it tries PATHEXT extensions, bare name last. */
+export function which(name, platform = process.platform, env = process.env) {
+    const dirs = (env.PATH ?? "").split(delimiter).filter(Boolean);
+    const candidates = platform === "win32"
+        ? [...(env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";").filter(Boolean).map((ext) => name + ext), name]
+        : [name];
+    for (const dir of dirs) {
+        for (const candidate of candidates) {
+            if (platform !== "win32") {
+                const full = join(dir, candidate);
+                if (existsSync(full))
+                    return full;
+                continue;
+            }
+            // Windows filesystems are case-insensitive; read the dir so a case difference still matches
+            let entries;
+            try {
+                entries = readdirSync(dir);
+            }
+            catch {
+                break;
+            }
+            const hit = entries.find((entry) => entry.toLowerCase() === candidate.toLowerCase());
+            if (hit)
+                return join(dir, hit);
+        }
+    }
+    return undefined;
+}
+/**
+ * Git for Windows' bash, for running bash-syntax commands on Windows. Never a bare `bash` from PATH: on Windows that
+ * can be WSL's System32\bash.exe, which resolves Windows paths differently.
+ */
+export function gitBash(platform = process.platform, env = process.env) {
+    if (platform !== "win32")
+        return undefined;
+    // Claude Code's own variable; trust it when it points at a real file
+    const override = env.CLAUDE_CODE_GIT_BASH_PATH;
+    if (override && existsSync(override))
+        return override;
+    const git = which("git", platform, env);
+    if (!git)
+        return undefined;
+    // Git for Windows: git.exe in <Git>\cmd, bash.exe in <Git>\bin
+    const bash = join(dirname(git), "..", "bin", "bash.exe");
+    return existsSync(bash) ? bash : undefined;
+}
+/** Double-quotes an argument Node will re-split under `shell: true` on Windows. */
+const quoteWinArg = (arg) => (/[\s"]/.test(arg) ? `"${arg.replace(/"/g, '\\"')}"` : arg);
+export function runCli(name, args, opts) {
+    const file = which(name);
+    if (!file)
+        return undefined;
+    if (/\.(cmd|bat)$/i.test(file)) {
+        return spawnSync(file, args.map(quoteWinArg), { ...opts, shell: true, windowsHide: true });
+    }
+    return spawnSync(file, args, opts);
+}

package/dist/research.js

@@ -10,7 +10,7 @@ import { projectScripts, researchRuleset } from "./permissions.js";
 import { normalisePath } from "./platform.js";
 import { failBlock, renderResearch } from "./report.js";
 import { chain, modelName, recordSpend, runRouted } from "./routing.js";
-import { openSession } from "./worker.js";
+import { openSession, releaseDirectory } from "./worker.js";
 import { createWorktree, projectRoot, removeWorktree } from "./workspace.js";
 /**
  * Research: one question about the codebase, answered by a worker that reads, searches and runs test commands but
@@ -32,13 +32,13 @@ export async function research(input, ctx) {
         return gate.block;
     const scope = [];
     for (const path of (input.paths ?? "").split(",").map((p) => p.trim()).filter(Boolean)) {
-        const rel = relative(root, join(root, path));
+        const rel = normalisePath(relative(root, join(root, path)));
         if (isAbsolute(path) || rel === ".." || rel.startsWith("../"))
             return failBlock(`path ${path} must be inside the repository, relative to its root`);
         if (!existsSync(join(root, path)))
             return failBlock(`path ${path} not found`);
         if (rel)
-            scope.push(normalisePath(rel)); // "." is the whole repo: no scope
+            scope.push(rel); // "." is the whole repo: no scope
     }
     let config;
     try {
@@ -127,8 +127,10 @@ export async function research(input, ctx) {
     }
     finally {
         release(); // the session is done: a config change may reboot OpenCode now
-        if (worktree)
+        if (worktree) {
+            await releaseDirectory(worktree.path); // release before the worktree is removed
             removeWorktree(root, worktree);
+        }
     }
     const answer = stopped ? { status: stopped.status, answer: "", refs: [] }
         : budget ? { status: "BUDGET", answer: "", refs: [] }
@@ -212,13 +214,17 @@ export function parseAnswer(text, root, scope, maxWords) {
         deadEnds: fields.deadEnds?.trim() && !/^none\.?$/i.test(fields.deadEnds.trim()) ? fields.deadEnds.trim() : undefined,
     };
 }
+/** The raw `path:line(-line)` candidates in text, before validation. Accepts a Windows drive letter and backslashes. */
+export function refTokens(text) {
+    return [...text.matchAll(/((?:[A-Za-z]:)?[\w./\\@-]+):(\d+)(?:-(\d+))?/g)].map(([, path, from, to]) => ({ path, from, to }));
+}
 /**
  * Validated `path:line(-line)` refs from free text, at most 5: the file exists in the main checkout, inside the repo
  * (and the scope, when there is one), and has those lines. Absolute paths inside the repo are made relative.
  */
 function refs(text, root, scope) {
     const out = [];
-    for (const [, path, from, to] of text.matchAll(/([\w./@-]+):(\d+)(?:-(\d+))?/g)) {
+    for (const { path, from, to } of refTokens(text)) {
         const abs = isAbsolute(path) ? path : join(root, path);
         const rel = normalisePath(relative(root, abs));
         const start = Number(from);

package/dist/server.js

@@ -9,7 +9,6 @@ import { detectProvider, NO_PROVIDER, redact } from "./credentials.js";
 import { delegate, jobs, landJobs, recoverJobs, reply } from "./jobs.js";
 import { ensureOpencode, stopOpencode } from "./opencode.js";
 import { PLAN_FORMAT } from "./plan.js";
-import { isSupported, UNSUPPORTED } from "./platform.js";
 import { failBlock } from "./report.js";
 import { MAX_WORDS, research } from "./research.js";
 import { DIFFICULTIES } from "./routing.js";
@@ -64,15 +63,13 @@ export async function serve() {
         const hint = gitignoreHint(process.cwd());
         return hint ? `${text}\n\n${hint}` : text;
     };
-    /** Answers every tool with the unsupported-platform FAIL on native Windows (spec A18). */
-    const supported = (handler) => (...args) => (isSupported() ? handler(...args) : Promise.resolve(safeText(UNSUPPORTED)));
     /** Worker progress as MCP progress notifications to the calling request, when it asked for them. */
     const progressTo = (extra) => (progress, message) => {
         const progressToken = extra._meta?.progressToken;
         if (progressToken !== undefined)
             void extra.sendNotification({ method: "notifications/progress", params: { progressToken, progress, message } });
     };
-    server.registerTool("ping", { description: "Check that the Cheap Agent server is running and report its version." }, supported(async () => {
+    server.registerTool("ping", { description: "Check that the Cheap Agent server is running and report its version." }, async () => {
         const provider = detectProvider();
         if (!provider)
             return safeText(NO_PROVIDER);
@@ -83,7 +80,7 @@ export async function serve() {
         catch (err) {
             return safeText(`FAIL reason: ${err.message}`);
         }
-    }));
+    });
     server.registerTool("delegate", {
         description: `Make any code change: use this for every edit, including small, mechanical, "quick" or multi-file ones; those are exactly what the cheap worker is for, and your tokens cost the user far more than its. One call: task = what to change, which files, how to check. The worker edits an isolated worktree, runs the checks, and lands an OK result (uncommitted) in your working tree; read the result block instead of re-checking. ${DIFFICULTY_HINT} For multi-step work pass plan + steps instead of task. ${PLAN_FORMAT}`,
         inputSchema: {
@@ -99,7 +96,7 @@ export async function serve() {
             wait: z.boolean().optional().describe('Default true: return when every group settles or one is BLOCKED. false: return RUNNING at once; then jobs(action="wait")'),
         },
         _meta: ALWAYS_LOAD,
-    }, supported(async (input, extra) => {
+    }, async (input, extra) => {
         const provider = detectProvider();
         if (!provider)
             return safeText(NO_PROVIDER);
@@ -109,7 +106,7 @@ export async function serve() {
         catch (err) {
             return safeText(failBlock(err.message));
         }
-    }));
+    });
     server.registerTool("research", {
         description: "Find and explain code in this repository: asks the cheap read-only research worker a question (it reads the working tree, uncommitted changes included). Returns a short answer with path:line refs and a confidence; verify low-confidence answers before acting.",
         inputSchema: {
@@ -118,7 +115,7 @@ export async function serve() {
             max_words: z.number().int().positive().optional().describe(`Answer length cap in words; default 200, at most ${MAX_WORDS}`),
         },
         _meta: ALWAYS_LOAD,
-    }, supported(async (input, extra) => {
+    }, async (input, extra) => {
         const provider = detectProvider();
         if (!provider)
             return safeText(NO_PROVIDER);
@@ -128,14 +125,14 @@ export async function serve() {
         catch (err) {
             return safeText(failBlock(err.message));
         }
-    }));
+    });
     server.registerTool("reply", {
         description: "Answer a BLOCKED job's question and resume its worker in the same session. Returns the job's next result block (OK, FAIL, or BLOCKED again); for a job in a batch, the batch block at its next settlement.",
         inputSchema: {
             job: z.string().describe('The BLOCKED job id, e.g. "j6a90"'),
             answer: z.string().max(500).describe('An option letter (a-d), or a short free-text answer; for several numbered questions, one answer each: "1a, 2b" or "1a, 2: use redis"'),
         },
-    }, supported(async (input, extra) => {
+    }, async (input, extra) => {
         if (!detectProvider())
             return safeText(NO_PROVIDER);
         try {
@@ -144,14 +141,14 @@ export async function serve() {
         catch (err) {
             return safeText(failBlock(err.message));
         }
-    }));
+    });
     server.registerTool("jobs", {
         description: "List jobs, show a job's last result block again, wait for a job or batch to settle, or cancel a running job (keeps its worktree).",
         inputSchema: {
             action: z.enum(["list", "show", "wait", "cancel"]).describe("list: one line per job; show: a job's last block; wait: block until the job's or batch's next result, then return it; cancel: stop a running job"),
             job: z.string().optional().describe("Job id, e.g. j7f3a (show, wait, cancel), or batch id, e.g. b4k1x (wait)"),
         },
-    }, supported(async (input, extra) => {
+    }, async (input, extra) => {
         if (!detectProvider())
             return safeText(NO_PROVIDER);
         try {
@@ -160,14 +157,14 @@ export async function serve() {
         catch (err) {
             return safeText(failBlock(err.message));
         }
-    }));
+    });
     server.registerTool("land", {
         description: "Land or discard finished jobs that did not land (PARTIAL, FAIL, CONFLICT…). apply: 3-way applies a job's worktree changes to your working tree, uncommitted (a conflict leaves the tree untouched); discard: deletes its worktree. One line per job.",
         inputSchema: {
             job: z.string().describe('Job id, or several comma-separated in landing order, e.g. "j3d55" or "j3d54,j3d55" (apply stops at the first that fails)'),
             action: z.enum(["apply", "discard"]).describe("apply: land the job's changes; discard: delete its worktree"),
         },
-    }, supported(async (input, extra) => {
+    }, async (input, extra) => {
         const provider = detectProvider();
         if (!provider)
             return safeText(NO_PROVIDER);
@@ -178,7 +175,7 @@ export async function serve() {
         catch (err) {
             return safeText(failBlock(err.message));
         }
-    }));
+    });
     // jobs a previous server left running or blocked can never finish now
     try {
         recoverJobs(process.cwd());
@@ -194,10 +191,24 @@ export async function serve() {
     catch {
         // not a repository, or a bad config (delegate reports that): nothing to clean
     }
-    process.on("exit", () => stopOpencode(true));
+    // CHEAPAG_DEBUG_SHUTDOWN=1 traces each shutdown point to stderr (CI logs); silent otherwise
+    const shutdownLog = (line) => {
+        if (process.env.CHEAPAG_DEBUG_SHUTDOWN === "1")
+            process.stderr.write(`cheapag-shutdown: ${line}\n`);
+    };
+    process.on("exit", () => {
+        shutdownLog("exit handler, stopping opencode");
+        stopOpencode(true);
+    });
     for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"])
-        process.on(signal, () => process.exit());
+        process.on(signal, () => {
+            shutdownLog(`signal ${signal}`);
+            process.exit();
+        });
     // Claude Code closing our stdin is the normal shutdown
-    process.stdin.on("end", () => process.exit());
+    process.stdin.on("end", () => {
+        shutdownLog("stdin end");
+        process.exit();
+    });
     await server.connect(new StdioServerTransport());
 }

package/dist/status.js

@@ -5,7 +5,7 @@ import { join } from "node:path";
 import { describe, presetHere, readConsent, routeMoved } from "./consent.js";
 import { detectProvider, LOGIN_COMMAND, providerLabel, redact } from "./credentials.js";
 import { blockedFor, records } from "./jobs.js";
-import { isAlive, isSupported, UNSUPPORTED_REASON } from "./platform.js";
+import { isAlive } from "./platform.js";
 import { renderJob } from "./report.js";
 import { spendWindows } from "./routing.js";
 import { projectRoot } from "./workspace.js";
@@ -17,10 +17,6 @@ const RECENT = 5;
  */
 export function status(args) {
     const out = (line) => process.stdout.write(redact(line) + "\n");
-    if (!isSupported()) {
-        out(`✗ ${UNSUPPORTED_REASON}`);
-        return 1;
-    }
     if (args.length) {
         out("✗ usage: cheapag status");
         return 1;

package/dist/verify.js

@@ -1,5 +1,5 @@
 import { spawn } from "node:child_process";
-import { killProcessGroup } from "./platform.js";
+import { gitBash, killProcessGroup, normalisePath } from "./platform.js";
 // a backstop per command; the job's minute cap (its `signal`) bounds the whole job
 const COMMAND_TIMEOUT_MS = 5 * 60_000;
 const OUTPUT_LIMIT = 1024 * 1024;
@@ -28,8 +28,13 @@ export async function runVerify(cwd, cmds, onStart, signal) {
 function runOne(cwd, cmd, signal) {
     const started = Date.now();
     return new Promise((resolve) => {
+        // checks are written in bash syntax; on Windows run them through Git Bash when we have it, else let Node pick the shell
+        const bash = process.platform === "win32" ? gitBash() : undefined;
+        const env = { ...process.env, CI: "1", FORCE_COLOR: "0" };
         // its own process group, so everything it spawned can be stopped with it
-        const child = spawn("sh", ["-c", cmd], { cwd, detached: true, stdio: ["ignore", "pipe", "pipe"], env: { ...process.env, CI: "1", FORCE_COLOR: "0" } });
+        const child = bash
+            ? spawn(bash, ["-c", cmd], { cwd, detached: true, windowsHide: true, stdio: ["ignore", "pipe", "pipe"], env })
+            : spawn(cmd, { shell: true, cwd, detached: true, windowsHide: true, stdio: ["ignore", "pipe", "pipe"], env });
         const killGroup = () => killProcessGroup(child.pid, "SIGKILL");
         let output = "";
         let code = null;
@@ -76,9 +81,11 @@ const MAX_LINES = 25;
  * Falls back to the last lines when no failure marker is found.
  */
 export function errorTail(run, root) {
+    // Windows output can hold root natively (`C:\r\repo`) or forward-slash; strip it and forward-slash the rest
+    const rootRe = [root, normalisePath(root)].map(escapeRe).join("|");
     const lines = run.output
         .replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "")
-        .split(`${root}/`).join("")
+        .replace(new RegExp(`(?:${rootRe})[\\\\/]([^\\s:'"\\[\\]()]*)`, "g"), (_, rest) => rest.replace(/\\/g, "/"))
         .split(/\r?\n/)
         .map((l) => l.replace(/\t/g, "  ").trimEnd())
         .filter((l) => l.trim() && (MARKER.test(l) || !NOISE.test(l)));
@@ -119,3 +126,5 @@ export function errorTail(run, root) {
 export const sameFailure = (a, b) => a.join("\n").replace(/\d+/g, "#") === b.join("\n").replace(/\d+/g, "#");
 /** At most 200 chars, eliding the middle. */
 const clip = (line) => (line.length <= 200 ? line : `${line.slice(0, 120)} … ${line.slice(-77)}`);
+/** Escapes a string for literal use inside a RegExp. */
+const escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");

package/dist/worker.js

@@ -1,4 +1,5 @@
 import { createOpencodeClient } from "@opencode-ai/sdk/v2";
+import { runningOpencode } from "./opencode.js";
 import { rejectionMessage } from "./permissions.js";
 import { modelName } from "./routing.js";
 /** Worker: one OpenCode session for one job, reduced to what the job layer needs. */
@@ -175,6 +176,27 @@ export async function openSession(opts) {
     }
     return { sessionID, run, totals };
 }
+/**
+ * Disposes the OpenCode instance for `directory`: nothing it still holds open then keeps the directory from being
+ * removed (Windows cannot delete one), and a long-lived server does not keep a watcher per past job. Best effort:
+ * no running server, or any error, changes nothing.
+ */
+export async function releaseDirectory(directory) {
+    const opencode = await runningOpencode();
+    if (!opencode)
+        return;
+    try {
+        const client = createOpencodeClient({
+            baseUrl: opencode.url,
+            directory,
+            headers: { authorization: `Basic ${Buffer.from(`opencode:${opencode.password}`).toString("base64")}` },
+        });
+        await client.instance.dispose({ directory }, { signal: AbortSignal.timeout(10_000) });
+    }
+    catch {
+        // best effort: a failed dispose must never fail a job
+    }
+}
 /** One prompt in a fresh session (the login live check). */
 export async function runSession(opts) {
     const session = await openSession(opts);

package/dist/workspace.js

@@ -1,15 +1,18 @@
 import { execFileSync, spawnSync } from "node:child_process";
 import { randomBytes } from "node:crypto";
 import { copyFileSync, cpSync, existsSync, linkSync, lstatSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
-import { dirname, join, relative } from "node:path";
+import { dirname, join, relative, resolve } from "node:path";
 import { isAlive, link, normalisePath, removeLink } from "./platform.js";
+// Git for Windows refuses paths over 260 chars unless long paths are on; the flag is a no-op elsewhere
+const GIT_ARGS = process.platform === "win32" ? ["-c", "core.longpaths=true"] : [];
 export function git(cwd, args, env) {
-    return execFileSync("git", args, { cwd, stdio: "pipe", env: env && { ...process.env, ...env }, maxBuffer: 256 * 1024 * 1024 }).toString();
+    return execFileSync("git", [...GIT_ARGS, ...args], { cwd, stdio: "pipe", env: env && { ...process.env, ...env }, maxBuffer: 256 * 1024 * 1024 }).toString();
 }
 /** The repository root containing `cwd`; throws when it is not a git repository. */
 export function projectRoot(cwd) {
     try {
-        return git(cwd, ["rev-parse", "--show-toplevel"]).trim();
+        // resolved: git prints forward slashes on Windows (C:/x/y); path.* gives the platform's own separators
+        return resolve(git(cwd, ["rev-parse", "--show-toplevel"]).trim());
     }
     catch {
         throw new Error(`${cwd} is not inside a git repository`);
@@ -55,7 +58,7 @@ export function createWorktree(root, job, linkDirs) {
     }
     const linked = links.map((l) => normalisePath(relative(path, l)));
     // the carried-over state as a tree object: the job's baseline, without committing anything
-    git(path, ["add", "-A", "--", ".", ...outside(linked)]);
+    git(path, ["add", "-A", "--", ".", ...outside(notIgnored(path, linked))]);
     const base = git(path, ["write-tree"]).trim();
     return { path, head, stash, base, links, linked };
 }
@@ -66,13 +69,17 @@ function discard(root, path, links) {
         git(root, ["worktree", "remove", "--force", path]);
     }
     catch {
-        // git no longer knows it (pruned by hand): rm never follows symlinks
-        rmSync(path, { recursive: true, force: true });
+        // git no longer knows it (pruned by hand): rm never follows symlinks.
+        // OpenCode releases a disposed directory's handles asynchronously, and Windows refuses to
+        // delete a directory that is still open; rmSync only retries EBUSY/EPERM-type errors.
+        rmSync(path, { recursive: true, force: true, maxRetries: 10, retryDelay: 200 });
         git(root, ["worktree", "prune"]);
     }
 }
 /** Pathspecs that keep Cheap Agent's state and the given dependency dirs out of a git operation. */
 const outside = (dirs) => [".cheapag", ...dirs].map((d) => `:(exclude,top,literal)${d}`);
+// git 2.55 rejects a pathspec naming an ignored path, even as an exclusion; an already-ignored dir needs no exclusion
+const notIgnored = (dir, paths) => paths.filter((p) => spawnSync("git", [...GIT_ARGS, "check-ignore", "-q", "--", p], { cwd: dir, stdio: "pipe" }).status !== 0);
 const isDirectory = (path) => {
     try {
         return statSync(path).isDirectory();
@@ -86,7 +93,7 @@ export function worktreeDiff(worktree) {
     const { path, base } = worktree;
     // the worktree's own index: throwaway, never committed. A linked dir is a symlink, which a `node_modules/`
     // ignore rule does not match, so the linked ones (only those: a tracked vendor/ stays in) are excluded.
-    git(path, ["add", "-A", "--", ".", ...outside(worktree.linked)]);
+    git(path, ["add", "-A", "--", ".", ...outside(notIgnored(path, worktree.linked))]);
     const patch = git(path, ["diff", "--cached", "--binary", base]);
     const stats = git(path, ["diff", "--cached", "--numstat", "-z", "--no-renames", base]).split("\0").filter(Boolean);
     const statuses = new Map();
@@ -236,7 +243,7 @@ export function land(root, job, patch, paths) {
 }
 /** git apply's verdict lives in stderr even when it exits 0. */
 function applyOutput(root, args, env, patch) {
-    const r = spawnSync("git", args, { cwd: root, env: { ...process.env, ...env }, input: patch, encoding: "utf8", maxBuffer: 256 * 1024 * 1024 });
+    const r = spawnSync("git", [...GIT_ARGS, ...args], { cwd: root, env: { ...process.env, ...env }, input: patch, encoding: "utf8", maxBuffer: 256 * 1024 * 1024 });
     return { failed: r.status !== 0, output: `${r.stdout}${r.stderr}` };
 }
 /** The paths a failed landing names as conflicting, from git apply's messages. */
@@ -254,7 +261,7 @@ export function reapply(worktree, patch) {
 }
 /** Paths whose changes still add conflict marker lines; run after `worktreeDiff`, which stages the worktree. */
 export function leftoverMarkers(worktree) {
-    const r = spawnSync("git", ["diff", "--cached", "--check", worktree.base], { cwd: worktree.path, encoding: "utf8", maxBuffer: 256 * 1024 * 1024 });
+    const r = spawnSync("git", [...GIT_ARGS, "diff", "--cached", "--check", worktree.base], { cwd: worktree.path, encoding: "utf8", maxBuffer: 256 * 1024 * 1024 });
     return [...new Set([...r.stdout.matchAll(/^(.+?):\d+: leftover conflict marker$/gm)].map((m) => m[1]))];
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cheap-agent",
-  "version": "1.0.0",
+  "version": "1.1.1",
   "description": "Cut your Claude Code usage: Claude plans, a cheap model writes the code. One command to install.",
   "license": "Elastic-2.0",
   "author": "muaaz9329",

package/plugin/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "cheapag",
   "displayName": "Cheap Agent",
-  "version": "1.0.0",
+  "version": "1.1.1",
   "description": "Claude plans and reviews while a cheaper model implements: the cheapag MCP server, the plan-writing skill, status, allow, hook and clean commands, and an opt-in edit guard.",
   "author": { "name": "muaaz9329" },
   "keywords": ["delegation", "opencode", "mcp", "cost"]

package/plugin/.mcp.json

@@ -2,7 +2,7 @@
   "mcpServers": {
     "cheapag": {
       "command": "npx",
-      "args": ["-y", "cheap-agent@1.0.0"]
+      "args": ["-y", "cheap-agent@1.1.1"]
     }
   }
 }

package/plugin/hooks/hooks.json

@@ -7,7 +7,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "r=$(git rev-parse --show-toplevel 2>/dev/null) && { [ -f \"$r/.cheapag/hook.json\" ] || [ -f \"$r/.cheapag/hook/takeover\" ]; } && npx -y cheap-agent@1.0.0 hook guard; exit 0",
+            "command": "r=$(git rev-parse --show-toplevel 2>/dev/null) && { [ -f \"$r/.cheapag/hook.json\" ] || [ -f \"$r/.cheapag/hook/takeover\" ]; } && npx -y cheap-agent@1.1.1 hook guard; exit 0",
             "timeout": 60
           }
         ]
@@ -19,7 +19,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "npx -y cheap-agent@1.0.0 hook result; exit 0",
+            "command": "npx -y cheap-agent@1.1.1 hook result; exit 0",
             "timeout": 60
           }
         ]
@@ -30,7 +30,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "npx -y cheap-agent@1.0.0 hook context",
+            "command": "npx -y cheap-agent@1.1.1 hook context",
             "timeout": 60
           }
         ]

package/plugin/skills/allow/SKILL.md

@@ -3,9 +3,9 @@ name: allow
 description: Opt this repository in to sending code to Cheap Agent's worker models - all models, --zdr-only (zero-retention only), or --models provider/model,...
 argument-hint: "[--zdr-only | --models provider/model,...]"
 disable-model-invocation: true
-allowed-tools: Bash(npx -y cheap-agent@1.0.0 allow) Bash(npx -y cheap-agent@1.0.0 allow *)
+allowed-tools: Bash(npx -y cheap-agent@1.1.1 allow) Bash(npx -y cheap-agent@1.1.1 allow *)
 ---
 
-!`npx -y cheap-agent@1.0.0 allow $ARGUMENTS`
+!`npx -y cheap-agent@1.1.1 allow $ARGUMENTS`
 
 The developer ran this consent command themselves; its output is above. Report it in one line. Do not run `cheapag allow` or change consent in any other way.

package/plugin/skills/clean/SKILL.md

@@ -3,9 +3,9 @@ name: clean
 description: Remove Cheap Agent's old worktrees and job logs now; --all removes everything not in flight.
 argument-hint: "[--all]"
 disable-model-invocation: true
-allowed-tools: Bash(npx -y cheap-agent@1.0.0 clean) Bash(npx -y cheap-agent@1.0.0 clean *)
+allowed-tools: Bash(npx -y cheap-agent@1.1.1 clean) Bash(npx -y cheap-agent@1.1.1 clean *)
 ---
 
-!`npx -y cheap-agent@1.0.0 clean $ARGUMENTS`
+!`npx -y cheap-agent@1.1.1 clean $ARGUMENTS`
 
 Report the result above to the user in one or two lines.

package/plugin/skills/hook/SKILL.md

@@ -3,9 +3,9 @@ name: hook
 description: Turn Cheap Agent's edit guard on or off for this repo - when on, Claude's large edits (or a 3rd edit to one file in a turn) are denied and redirected to delegate.
 argument-hint: "[on | off]"
 disable-model-invocation: true
-allowed-tools: Bash(npx -y cheap-agent@1.0.0 hook) Bash(npx -y cheap-agent@1.0.0 hook *)
+allowed-tools: Bash(npx -y cheap-agent@1.1.1 hook) Bash(npx -y cheap-agent@1.1.1 hook *)
 ---
 
-!`npx -y cheap-agent@1.0.0 hook $ARGUMENTS`
+!`npx -y cheap-agent@1.1.1 hook $ARGUMENTS`
 
 The developer ran this command themselves; its output is above. Report it in one line. Do not turn the edit guard on or off in any other way.

package/plugin/skills/status/SKILL.md

@@ -1,9 +1,9 @@
 ---
 name: status
 description: Show Cheap Agent's status for this repo - running jobs, recent results, consent, and tracked spend against OpenCode Go windows.
-allowed-tools: Bash(npx -y cheap-agent@1.0.0 status)
+allowed-tools: Bash(npx -y cheap-agent@1.1.1 status)
 ---
 
-!`npx -y cheap-agent@1.0.0 status`
+!`npx -y cheap-agent@1.1.1 status`
 
 Show the status above to the user as is. Add a line only if something needs their action (a BLOCKED job to reply to, a missing consent, a Go window near its cap).