forge-cw 0.1.12 → 0.1.13

package/dist/index.js

@@ -1,13 +1,36 @@
 #!/usr/bin/env node
+var __create = Object.create;
 var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 
 // ../core/dist/db.js
 import { randomUUID } from "node:crypto";
@@ -71,6 +94,28 @@ var init_db = __esm({
         value TEXT NOT NULL,
         PRIMARY KEY (module_id, key)
       );
+
+      CREATE TABLE IF NOT EXISTS module_kv (
+        module_id TEXT NOT NULL,
+        key TEXT NOT NULL,
+        value TEXT NOT NULL,
+        updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+        PRIMARY KEY (module_id, key)
+      );
+
+      CREATE TABLE IF NOT EXISTS module_notifications (
+        module_id TEXT NOT NULL,
+        key TEXT NOT NULL,
+        kind TEXT NOT NULL,
+        title TEXT NOT NULL DEFAULT '',
+        body TEXT,
+        version TEXT,
+        count INTEGER,
+        label TEXT,
+        created_at TEXT NOT NULL DEFAULT (datetime('now')),
+        seen_at TEXT,
+        PRIMARY KEY (module_id, key)
+      );
     `);
       }
       listTables() {
@@ -159,6 +204,57 @@ var init_db = __esm({
       setModuleSetting(moduleId, key, value) {
         this.db.prepare("INSERT INTO module_settings (module_id, key, value) VALUES (?, ?, ?) ON CONFLICT(module_id, key) DO UPDATE SET value = excluded.value").run(moduleId, key, value);
       }
+      kvGet(moduleId, key) {
+        const row = this.db.prepare("SELECT value FROM module_kv WHERE module_id = ? AND key = ?").get(moduleId, key);
+        return row?.value;
+      }
+      kvSet(moduleId, key, json) {
+        this.db.prepare("INSERT INTO module_kv (module_id, key, value) VALUES (?, ?, ?) ON CONFLICT(module_id, key) DO UPDATE SET value = excluded.value, updated_at = datetime('now')").run(moduleId, key, json);
+      }
+      kvDelete(moduleId, key) {
+        this.db.prepare("DELETE FROM module_kv WHERE module_id = ? AND key = ?").run(moduleId, key);
+      }
+      kvList(moduleId, prefix = "") {
+        const rows = this.db.prepare("SELECT key FROM module_kv WHERE module_id = ? AND substr(key, 1, ?) = ? ORDER BY key").all(moduleId, prefix.length, prefix);
+        return rows.map((r) => r.key);
+      }
+      // true when the row is new or its version changed; a changed version is unseen again
+      upsertNotification(row) {
+        const current = this.db.prepare("SELECT version, title, body, count, label FROM module_notifications WHERE module_id = ? AND key = ?").get(row.moduleId, row.key);
+        const version = row.version ?? null;
+        if (current && current.version === version) {
+          this.db.prepare("UPDATE module_notifications SET title = ?, body = ?, count = ?, label = ? WHERE module_id = ? AND key = ?").run(row.title, row.body ?? null, row.count ?? null, row.label ?? null, row.moduleId, row.key);
+          return false;
+        }
+        this.db.prepare(`INSERT INTO module_notifications (module_id, key, kind, title, body, version, count, label) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(module_id, key) DO UPDATE SET kind = excluded.kind, title = excluded.title, body = excluded.body, version = excluded.version,
+       count = excluded.count, label = excluded.label, created_at = datetime('now'), seen_at = NULL`).run(row.moduleId, row.key, row.kind, row.title, row.body ?? null, version, row.count ?? null, row.label ?? null);
+        return true;
+      }
+      deleteNotification(moduleId, key) {
+        this.db.prepare("DELETE FROM module_notifications WHERE module_id = ? AND key = ?").run(moduleId, key);
+      }
+      listNotifications() {
+        const rows = this.db.prepare("SELECT * FROM module_notifications ORDER BY created_at, rowid").all();
+        return rows.map((r) => ({
+          moduleId: r.module_id,
+          key: r.key,
+          kind: r.kind,
+          title: r.title,
+          body: r.body ?? void 0,
+          version: r.version ?? void 0,
+          count: r.count ?? void 0,
+          label: r.label ?? void 0,
+          createdAt: r.created_at,
+          seenAt: r.seen_at ?? null
+        }));
+      }
+      markNotificationsSeen(moduleId) {
+        this.db.prepare("UPDATE module_notifications SET seen_at = datetime('now') WHERE module_id = ? AND seen_at IS NULL").run(moduleId);
+      }
+      deleteModuleSetting(moduleId, key) {
+        this.db.prepare("DELETE FROM module_settings WHERE module_id = ? AND key = ?").run(moduleId, key);
+      }
       listActionLogs(opts) {
         const { moduleId, limit = 50 } = opts;
         let sql = "SELECT * FROM action_logs";
@@ -238,6 +334,8 @@ var init_modules = __esm({
         try {
           const raw = readFileSync(manifestPath, "utf-8");
           const manifest = JSON.parse(raw);
+          if (manifest.sdk !== void 0)
+            return void 0;
           this.loaded.set(dirName, manifest);
           return manifest;
         } catch {
@@ -268,11 +366,18 @@ var init_runner = __esm({
     "use strict";
     ActionRunner = class {
       async exec(command, options) {
-        return new Promise((resolve5) => {
+        return this.run("sh", ["-c", command], options);
+      }
+      // no shell: the args reach the program as they are
+      async spawn(command, args, options) {
+        return this.run(command, args, options);
+      }
+      run(file, args, options) {
+        return new Promise((resolve10) => {
           let output = "";
           let timedOut = false;
           let timeoutId;
-          const proc = spawn("sh", ["-c", command], {
+          const proc = spawn(file, args, {
             cwd: options.cwd,
             env: { ...process.env, ...options.env },
             stdio: ["ignore", "pipe", "pipe"],
@@ -305,7 +410,7 @@ var init_runner = __esm({
           proc.on("close", (code) => {
             if (timeoutId)
               clearTimeout(timeoutId);
-            resolve5({
+            resolve10({
               exitCode: code ?? 1,
               output,
               timedOut
@@ -314,7 +419,7 @@ var init_runner = __esm({
           proc.on("error", () => {
             if (timeoutId)
               clearTimeout(timeoutId);
-            resolve5({ exitCode: 1, output, timedOut });
+            resolve10({ exitCode: 1, output, timedOut });
           });
         });
       }
@@ -831,19 +936,19 @@ function envWithoutHarness(env = process.env) {
   return out;
 }
 function runDoctor(cwBin) {
-  return new Promise((resolve5) => {
+  return new Promise((resolve10) => {
     execFile(cwBin, ["doctor", "--json"], { timeout: TIMEOUT_MS, env: envWithoutHarness(), maxBuffer: 10 * 1024 * 1024 }, (err, stdout) => {
       if (err)
-        return resolve5({ available: false, reason: err.message });
+        return resolve10({ available: false, reason: err.message });
       let parsed;
       try {
         parsed = JSON.parse(stdout);
       } catch {
-        return resolve5({ available: false, reason: "cw doctor --json did not print JSON" });
+        return resolve10({ available: false, reason: "cw doctor --json did not print JSON" });
       }
       if (parsed.schema !== 1)
-        return resolve5({ available: false, reason: `unsupported doctor schema ${String(parsed.schema)}` });
-      resolve5({ available: true, doctor: parsed });
+        return resolve10({ available: false, reason: `unsupported doctor schema ${String(parsed.schema)}` });
+      resolve10({ available: true, doctor: parsed });
     });
   });
 }
@@ -948,14 +1053,14 @@ function closeWarningsFor(input) {
   return warnings;
 }
 function createRunner(env, timeoutMs = COMMAND_TIMEOUT_MS) {
-  return (bin, args, cwd, input) => new Promise((resolve5) => {
+  return (bin, args, cwd, input) => new Promise((resolve10) => {
     const child = execFile2(bin, args, { cwd, env, timeout: timeoutMs, maxBuffer: 5 * 1024 * 1024 }, (err, stdout, stderr) => {
       if (!err)
-        return resolve5({ code: 0, stdout: String(stdout), stderr: String(stderr) });
+        return resolve10({ code: 0, stdout: String(stdout), stderr: String(stderr) });
       const { code } = err;
       if (code === "ENOENT")
-        return resolve5({ code: 127, stdout: "", stderr: "ENOENT" });
-      resolve5({ code: typeof code === "number" ? code : 1, stdout: String(stdout), stderr: String(stderr) || err.message });
+        return resolve10({ code: 127, stdout: "", stderr: "ENOENT" });
+      resolve10({ code: typeof code === "number" ? code : 1, stdout: String(stdout), stderr: String(stderr) || err.message });
     });
     if (input !== void 0) {
       child.stdin?.on("error", () => {
@@ -976,11 +1081,11 @@ function isCwLink(worktree, porcelainLine) {
     return false;
   }
 }
-async function readGitSnapshot(run, worktree) {
-  const head = await run("git", ["rev-parse", "--abbrev-ref", "HEAD"], worktree);
+async function readGitSnapshot(run2, worktree) {
+  const head = await run2("git", ["rev-parse", "--abbrev-ref", "HEAD"], worktree);
   if (head.code !== 0)
     throw new GitReadError(head.stderr.trim() || "git rev-parse failed");
-  const status = await run("git", ["status", "--porcelain", "--untracked-files=all"], worktree);
+  const status = await run2("git", ["status", "--porcelain", "--untracked-files=all"], worktree);
   if (status.code !== 0)
     throw new GitReadError(status.stderr.trim() || "git status failed");
   const branchName = head.stdout.trim();
@@ -989,14 +1094,14 @@ async function readGitSnapshot(run, worktree) {
   let unpushed = null;
   if (branch) {
     const remoteRef = `refs/remotes/origin/${branch}`;
-    const verify = await run("git", ["rev-parse", "--verify", "--quiet", remoteRef], worktree);
+    const verify = await run2("git", ["rev-parse", "--verify", "--quiet", remoteRef], worktree);
     if (verify.code === 0) {
       upstream = `origin/${branch}`;
-      const count = await run("git", ["rev-list", "--count", `${remoteRef}..HEAD`], worktree);
+      const count = await run2("git", ["rev-list", "--count", `${remoteRef}..HEAD`], worktree);
       unpushed = count.code === 0 ? Number(count.stdout.trim()) : null;
     }
   }
-  const remote = await run("git", ["remote", "get-url", "origin"], worktree);
+  const remote = await run2("git", ["remote", "get-url", "origin"], worktree);
   return {
     branch,
     uncommitted: lines(status.stdout).filter((line) => !isCwLink(worktree, line)).length,
@@ -1005,28 +1110,28 @@ async function readGitSnapshot(run, worktree) {
     repo: remote.code === 0 ? parseGitHubRemote(remote.stdout) : null
   };
 }
-async function resolveBase(run, cwd, candidates) {
+async function resolveBase(run2, cwd, candidates) {
   for (const candidate of candidates) {
     if (!candidate)
       continue;
     let ref = candidate;
     if (candidate === "origin/HEAD") {
-      const head = await run("git", ["symbolic-ref", "--quiet", "refs/remotes/origin/HEAD"], cwd);
+      const head = await run2("git", ["symbolic-ref", "--quiet", "refs/remotes/origin/HEAD"], cwd);
       if (head.code !== 0)
         continue;
       ref = head.stdout.trim().replace(/^refs\/remotes\//, "");
     }
-    const verify = await run("git", ["rev-parse", "--verify", "--quiet", `${ref}^{commit}`], cwd);
+    const verify = await run2("git", ["rev-parse", "--verify", "--quiet", `${ref}^{commit}`], cwd);
     if (verify.code === 0)
       return ref;
   }
   return null;
 }
-async function readBaseCounts(run, cwd, base) {
+async function readBaseCounts(run2, cwd, base) {
   if (!base)
     return { commits: null, diff: null };
-  const count = await run("git", ["rev-list", "--count", `${base}..HEAD`], cwd);
-  const stat = await run("git", ["diff", "--shortstat", base], cwd);
+  const count = await run2("git", ["rev-list", "--count", `${base}..HEAD`], cwd);
+  const stat = await run2("git", ["diff", "--shortstat", base], cwd);
   return {
     commits: count.code === 0 ? Number(count.stdout.trim()) : null,
     diff: stat.code === 0 ? parseShortstat(stat.stdout) : null
@@ -1051,8 +1156,8 @@ function ghUnavailable(result2) {
   const firstLine = result2.stderr.split("\n").map((line) => line.trim()).find((line) => line.length > 0);
   return { status: "unavailable", reason: firstLine ?? "gh failed" };
 }
-async function readPullRequestForBranch(run, cwd, branch) {
-  const result2 = await run("gh", ["pr", "list", "--head", branch, "--state", "all", "--limit", "1", "--json", PR_FIELDS], cwd);
+async function readPullRequestForBranch(run2, cwd, branch) {
+  const result2 = await run2("gh", ["pr", "list", "--head", branch, "--state", "all", "--limit", "1", "--json", PR_FIELDS], cwd);
   if (result2.code !== 0)
     return ghUnavailable(result2);
   try {
@@ -1064,8 +1169,8 @@ async function readPullRequestForBranch(run, cwd, branch) {
     return UNEXPECTED;
   }
 }
-async function readPullRequestByNumber(run, cwd, number) {
-  const result2 = await run("gh", ["pr", "view", number, "--json", PR_FIELDS], cwd);
+async function readPullRequestByNumber(run2, cwd, number) {
+  const result2 = await run2("gh", ["pr", "view", number, "--json", PR_FIELDS], cwd);
   if (result2.code !== 0)
     return ghUnavailable(result2);
   try {
@@ -1100,8 +1205,8 @@ async function buildReviewSessionState(session, projectPath, deps) {
   const github = githubLink({ repo, kind: "review", prNumber, pr, branch: null, base: null, upstream: null, commits: null, uncommitted: 0 });
   return { ...idleState("none"), pr, github };
 }
-async function isAncestor(run, cwd, ancestor, descendant) {
-  return (await run("git", ["merge-base", "--is-ancestor", ancestor, descendant], cwd)).code === 0;
+async function isAncestor(run2, cwd, ancestor, descendant) {
+  return (await run2("git", ["merge-base", "--is-ancestor", ancestor, descendant], cwd)).code === 0;
 }
 async function buildTaskReviewState(session, projectPath, deps) {
   if (session.type === "review")
@@ -1155,7 +1260,7 @@ function createLimiter(max) {
   const waiting = [];
   return async (fn) => {
     if (active >= max)
-      await new Promise((resolve5) => waiting.push(resolve5));
+      await new Promise((resolve10) => waiting.push(resolve10));
     else
       active++;
     try {
@@ -1355,7 +1460,7 @@ function mapCodexUsage(payload) {
   });
 }
 function callCodexAppServer(bin, codexHome, timeoutMs = TIMEOUT_MS3) {
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve10, reject) => {
     const child = spawn2(bin, ["app-server"], { env: { ...CHILD_ENV, CODEX_HOME: codexHome }, stdio: ["pipe", "pipe", "ignore"] });
     let buffer = "";
     let settled = false;
@@ -1375,7 +1480,7 @@ function callCodexAppServer(bin, codexHome, timeoutMs = TIMEOUT_MS3) {
     const done = (value) => {
       if (!settled) {
         stop();
-        resolve5(value);
+        resolve10(value);
       }
     };
     const timer = setTimeout(() => fail(new Error(`codex app-server did not answer in ${timeoutMs / 1e3} s`)), timeoutMs);
@@ -1642,7 +1747,7 @@ var init_login_manager = __esm({
 // ../core/dist/api-key-login.js
 import { spawn as spawn4 } from "node:child_process";
 function importApiKey(cwBin, account, harness, apiKey) {
-  return new Promise((resolve5) => {
+  return new Promise((resolve10) => {
     const redact = (text) => text.split(apiKey).join("***").trim();
     const child = spawn4(cwBin, ["account", "login", account, "--harness", harness, "--with-api-key", "-"], {
       env: envWithoutHarness(),
@@ -1659,11 +1764,11 @@ function importApiKey(cwBin, account, harness, apiKey) {
     const timer = setTimeout(() => child.kill(), TIMEOUT_MS4);
     child.on("error", (err) => {
       clearTimeout(timer);
-      resolve5({ ok: false, error: redact(err.message) });
+      resolve10({ ok: false, error: redact(err.message) });
     });
     child.on("close", (code) => {
       clearTimeout(timer);
-      resolve5(code === 0 ? { ok: true } : { ok: false, error: redact(output) || `cw exited with ${String(code)}` });
+      resolve10(code === 0 ? { ok: true } : { ok: false, error: redact(output) || `cw exited with ${String(code)}` });
     });
     child.stdin.end(`${apiKey}
 `);
@@ -1695,12 +1800,12 @@ function detectEditors(probe) {
   return found;
 }
 function openInEditor(editor, dir) {
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve10, reject) => {
     const child = spawn5(editor.bin, [...editor.args, dir], { detached: true, stdio: "ignore" });
     child.once("error", reject);
     child.once("spawn", () => {
       child.unref();
-      resolve5();
+      resolve10();
     });
   });
 }
@@ -1779,7 +1884,7 @@ function cwRoutes(reader, options = {}) {
   const app = new Hono();
   const cwBin = resolveCwBin(reader.cwHome);
   const logins = options.loginManager ?? new LoginManager(cwBin);
-  const run = options.runner ?? runCommand;
+  const run2 = options.runner ?? runCommand;
   const localOnly = options.localOnly ?? true;
   const editors = options.editors ?? detectEditors(systemProbe);
   const cwDoneTimeoutMs = options.cwDoneTimeoutMs ?? CW_DONE_TIMEOUT_MS;
@@ -1788,10 +1893,28 @@ function cwRoutes(reader, options = {}) {
   const reviewCache = /* @__PURE__ */ new Map();
   const knownAccount = (name) => ACCOUNT_NAME_RE.test(name) && reader.getAccounts().includes(name);
   const doctor = createDoctorClient(cwBin);
+  let cells = null;
+  const noteHarnesses = (accounts) => {
+    const next = /* @__PURE__ */ new Map();
+    for (const a of accounts)
+      for (const h of a.harnesses)
+        next.set(`${a.name}\0${h.harness}`, h.status);
+    if (cells && options.events) {
+      for (const [key, to] of next) {
+        const from = cells.get(key);
+        if (from === void 0 || from === to)
+          continue;
+        const [account, harness] = key.split("\0");
+        options.events.emit("harness.changed", { account, harness, from, to });
+      }
+    }
+    cells = next;
+  };
   app.get("/harnesses", async (c) => {
     const result2 = await doctor.get(c.req.query("fresh") === "1");
     if (!result2.available)
       return c.json(result2);
+    noteHarnesses(result2.doctor.accounts);
     const capabilities = Object.fromEntries(result2.doctor.harnesses.map((h) => [h.name, [...HARNESS_CAPABILITIES[h.name] ?? []]]));
     return c.json({ ...result2, capabilities, contextTokens: readContextTokens(reader.cwHome) });
   });
@@ -1877,8 +2000,8 @@ function cwRoutes(reader, options = {}) {
       return c.json({ ok: false, error: `Account "${name}" not found` }, 404);
     }
     try {
-      const { rmSync: rmSync3 } = await import("node:fs");
-      rmSync3(accountDir, { recursive: true, force: true });
+      const { rmSync: rmSync4 } = await import("node:fs");
+      rmSync4(accountDir, { recursive: true, force: true });
       return c.json({ ok: true });
     } catch (err) {
       const message = err instanceof Error ? err.message : "Unknown error";
@@ -1947,7 +2070,7 @@ function cwRoutes(reader, options = {}) {
       return c.json({ error: "Session not found" }, 404);
     if ("empty" in result2)
       return c.json({ output: "" });
-    const status = await run("git", ["status", "--short"], result2.session.worktree);
+    const status = await run2("git", ["status", "--short"], result2.session.worktree);
     return c.json({ output: status.code === 0 ? status.stdout : "" });
   });
   app.get("/git/log/:project/:sessionDir", async (c) => {
@@ -1956,7 +2079,7 @@ function cwRoutes(reader, options = {}) {
       return c.json({ error: "Session not found" }, 404);
     if ("empty" in result2)
       return c.json({ output: "" });
-    const log = await run("git", ["log", "--oneline", "-20"], result2.session.worktree);
+    const log = await run2("git", ["log", "--oneline", "-20"], result2.session.worktree);
     return c.json({ output: log.code === 0 ? log.stdout : "" });
   });
   app.get("/git/branch/:project/:sessionDir", async (c) => {
@@ -1965,7 +2088,7 @@ function cwRoutes(reader, options = {}) {
       return c.json({ error: "Session not found" }, 404);
     if ("empty" in result2)
       return c.json({ branch: "" });
-    const head = await run("git", ["rev-parse", "--abbrev-ref", "HEAD"], result2.session.worktree);
+    const head = await run2("git", ["rev-parse", "--abbrev-ref", "HEAD"], result2.session.worktree);
     return c.json({ branch: head.code === 0 ? head.stdout.trim() : "" });
   });
   app.get("/git/diff/:project/:sessionDir", async (c) => {
@@ -1975,10 +2098,10 @@ function cwRoutes(reader, options = {}) {
     if ("empty" in result2)
       return c.json({ output: "" });
     const worktree = result2.session.worktree;
-    const base = await resolveBase(run, worktree, [result2.session.base_branch, "origin/HEAD", "origin/main"]);
+    const base = await resolveBase(run2, worktree, [result2.session.base_branch, "origin/HEAD", "origin/main"]);
     if (!base)
       return c.json({ output: "" });
-    const diff = await run("git", ["diff", "--stat", base], worktree);
+    const diff = await run2("git", ["diff", "--stat", base], worktree);
     return c.json({ output: diff.code === 0 ? diff.stdout : "" });
   });
   app.get("/review-state/:project/:sessionDir", async (c) => {
@@ -1993,7 +2116,7 @@ function cwRoutes(reader, options = {}) {
       return c.json(await cached.value);
     }
     const projectPath = reader.getProjects()[project]?.path ?? null;
-    const value = buildTaskReviewState(session, projectPath, { run, limitGh, exists: existsSync5 });
+    const value = buildTaskReviewState(session, projectPath, { run: run2, limitGh, exists: existsSync5 });
     reviewCache.set(key, { at: Date.now(), value });
     value.catch(() => reviewCache.delete(key));
     return c.json(await value);
@@ -2280,8 +2403,20 @@ function cwRoutes(reader, options = {}) {
     const args = type === "review" ? ["review", project, task, "--done"] : type === "loop" ? ["loop", project, task, "--done"] : ["work", project, task, "--done"];
     reviewCache.delete(`${project}::${sessionDirName}`);
     const result2 = await runCw(cwBin, args, cwDoneTimeoutMs);
-    if (result2.code === 0)
+    if (result2.code === 0) {
+      const session = reader.getSession(project, sessionDirName);
+      options.events?.emit("task.done", {
+        project,
+        sessionDir: sessionDirName,
+        type: session?.type ?? type,
+        account: session?.account,
+        harness: session?.harness,
+        provider: session?.provider,
+        model: session?.model,
+        command: args[0]
+      });
       return c.json({ ok: true });
+    }
     const output = tailOutput(`${result2.stdout}
 ${result2.stderr}`);
     const error = result2.timedOut ? [cwDoneTimeoutMessage(cwDoneTimeoutMs), output].filter(Boolean).join("\n") : output || "cw --done failed";
@@ -2420,6 +2555,7 @@ ${result2.stderr}`);
       args.push("--type", type.trim());
     try {
       await execFileAsync2(cwBin, args, { encoding: "utf-8", timeout: 3e4, env: envWithoutHarness() });
+      options.events?.emit("project.registered", { project: projectName, path: projectPath });
       return c.json({ ok: true, project: projectName });
     } catch (err) {
       const message = err instanceof Error ? err.message : "Unknown error";
@@ -2467,12 +2603,12 @@ function normalizeRepo(value) {
   const m = value.trim().match(/^(?:git@github\.com:|(?:https?|ssh|git):\/\/(?:[^@/]+@)?github\.com\/)?([\w.-]+)\/([\w.-]+?)(?:\.git)?\/?$/i);
   return m ? `${m[1]}/${m[2]}`.toLowerCase() : void 0;
 }
-function createRemoteLookup(run) {
+function createRemoteLookup(run2) {
   const cache = /* @__PURE__ */ new Map();
   return (projectPath) => {
     let hit = cache.get(projectPath);
     if (!hit) {
-      hit = run("git", ["remote", "get-url", "origin"], projectPath).then((r) => r.code === 0 && r.stdout.trim() || null).catch(() => null);
+      hit = run2("git", ["remote", "get-url", "origin"], projectPath).then((r) => r.code === 0 && r.stdout.trim() || null).catch(() => null);
       cache.set(projectPath, hit);
     }
     return hit;
@@ -2683,9 +2819,9 @@ function skillRoutes(reader, options = {}) {
     busy.add(configDir);
     try {
       const { CLAUDE_CONFIG_DIR: _ignored, ...base } = envWithoutHarness();
-      const run = runnerFor(scope === "global" ? base : { ...base, CLAUDE_CONFIG_DIR: configDir });
+      const run2 = runnerFor(scope === "global" ? base : { ...base, CLAUDE_CONFIG_DIR: configDir });
       for (const args of commands) {
-        const result2 = await run("claude", args, configDir);
+        const result2 = await run2("claude", args, configDir);
         if (result2.code !== 0)
           return { error: `${failure}: ${commandFailure(result2)}`, status: 500 };
       }
@@ -2896,8 +3032,8 @@ function skillRoutes(reader, options = {}) {
     const args = ["--yes", "skills", "add", repo, "--skill", skill, "--agent", "claude-code", "--yes", "--json"];
     if (scope !== "project")
       args.push("--global");
-    const run = runnerFor({ ...envWithoutHarness(), CLAUDE_CONFIG_DIR: configDir });
-    const result2 = await run("npx", args, dirname2(configDir));
+    const run2 = runnerFor({ ...envWithoutHarness(), CLAUDE_CONFIG_DIR: configDir });
+    const result2 = await run2("npx", args, dirname2(configDir));
     if (result2.code !== 0) {
       return c.json({ error: `Failed to install skill: ${installFailure(result2)}` }, 500);
     }
@@ -3079,6 +3215,8 @@ var init_pty_manager = __esm({
       states;
       sessions = /* @__PURE__ */ new Map();
       cleanupTimer = null;
+      // told when a session's agent starts and when its process exits
+      onLifecycle;
       constructor(states = null) {
         this.states = states;
         this.cleanupTimer = setInterval(() => this.cleanup(), CLEANUP_INTERVAL_MS);
@@ -3091,12 +3229,12 @@ var init_pty_manager = __esm({
         const existing = this.sessions.get(key);
         if (existing)
           return existing;
-        const shell = process.env.SHELL || "/bin/zsh";
+        const shell2 = process.env.SHELL || "/bin/zsh";
         const { command, env } = buildLaunch(session, options.isNew ?? false);
         const cwd = session.worktree && existsSync8(session.worktree) ? session.worktree : session.type === "general" || session.type === "create" || session.type === "login" ? process.env.HOME ?? process.cwd() : process.cwd();
         let ptyProcess;
         try {
-          ptyProcess = pty2.spawn(shell, ["-c", command], {
+          ptyProcess = pty2.spawn(shell2, ["-c", command], {
             name: "xterm-256color",
             cols: 120,
             rows: 40,
@@ -3144,8 +3282,10 @@ var init_pty_manager = __esm({
             }
           }
           this.sessions.delete(key);
+          this.onLifecycle?.("ended", session);
         });
         this.sessions.set(key, ptySession);
+        this.onLifecycle?.("started", session);
         return ptySession;
       }
       attach(sessionId, client) {
@@ -3369,7 +3509,7 @@ var init_terminal_screen = __esm({
       }
       // rows oldest first, scrollback included, without the blank rows under the last one written
       read() {
-        return new Promise((resolve5) => this.term.write("", () => {
+        return new Promise((resolve10) => this.term.write("", () => {
           const buffer = this.term.buffer.active;
           const rows = [];
           for (let y = 0; y < buffer.length; y++) {
@@ -3385,7 +3525,7 @@ var init_terminal_screen = __esm({
           const trimmed = rows.map((r) => r.trimEnd());
           while (trimmed.length && !trimmed[trimmed.length - 1])
             trimmed.pop();
-          resolve5(trimmed.join("\n"));
+          resolve10(trimmed.join("\n"));
         }));
       }
       dispose() {
@@ -4075,7 +4215,7 @@ function failureMessage2(output) {
 async function ensureCw(options) {
   const { cwHome, bundleDir } = options;
   const env = options.env ?? process.env;
-  const run = options.run ?? runInstall;
+  const run2 = options.run ?? runInstall;
   const bin = join12(cwHome, "bin", "cw");
   const bundle = readCwBundle(bundleDir);
   const installed = existsSync11(bin) ? { version: readCwVersion(bin), sha256: sha256Of(bin) } : null;
@@ -4088,7 +4228,7 @@ async function ensureCw(options) {
   });
   if (decision.action === "skip" || !bundle)
     return { action: "skipped", message: decision.reason };
-  const { code, output } = await run(join12(bundle.dir, "install.sh"), ["--no-shell"], { ...env, CW_HOME: cwHome });
+  const { code, output } = await run2(join12(bundle.dir, "install.sh"), ["--no-shell"], { ...env, CW_HOME: cwHome });
   if (code !== 0 || !existsSync11(bin))
     return { action: "failed", message: failureMessage2(output) };
   const marker = { version: bundle.version, ref: bundle.ref, sha256: sha256Of(bin) };
@@ -4107,13 +4247,13 @@ var init_cw_install = __esm({
     INSTALL_TIMEOUT_MS2 = 12e4;
     ANSI_RE3 = /\u001b\[[0-9;?]*[A-Za-z]/g;
     sha256Of = (file) => createHash2("sha256").update(readFileSync9(file)).digest("hex");
-    runInstall = (script, args, env) => new Promise((resolve5) => {
+    runInstall = (script, args, env) => new Promise((resolve10) => {
       execFile5("bash", [script, ...args], { env, timeout: INSTALL_TIMEOUT_MS2, maxBuffer: 1024 * 1024 }, (err, stdout, stderr) => {
         const output = `${String(stdout)}${String(stderr)}`;
         if (!err)
-          return resolve5({ code: 0, output });
+          return resolve10({ code: 0, output });
         const code = err.code;
-        resolve5({ code: typeof code === "number" ? code : 1, output: output || err.message });
+        resolve10({ code: typeof code === "number" ? code : 1, output: output || err.message });
       });
     });
   }
@@ -4138,12 +4278,12 @@ function rememberPrompt(text) {
   return `Remember this with kioku: ${text.replace(/\s+/g, " ").trim()}`;
 }
 function createTerminalRunner(env, timeoutMs) {
-  return (bin, args, cwd) => new Promise((resolve5) => {
+  return (bin, args, cwd) => new Promise((resolve10) => {
     let proc;
     try {
       proc = pty3.spawn(bin, args, { name: "xterm-256color", cols: 400, rows: 40, cwd, env });
     } catch {
-      return resolve5({ code: 127, stdout: "", stderr: "ENOENT" });
+      return resolve10({ code: 127, stdout: "", stderr: "ENOENT" });
     }
     let output = "";
     const timer = setTimeout(() => proc.kill(), timeoutMs);
@@ -4153,7 +4293,7 @@ function createTerminalRunner(env, timeoutMs) {
     proc.onExit(({ exitCode }) => {
       clearTimeout(timer);
       const json = stripAnsi(output).split(/\r?\n/).reverse().map((line) => line.slice(line.indexOf("{")).trim()).find((line) => parseJson(line) !== null);
-      resolve5({ code: exitCode, stdout: json ?? "", stderr: output });
+      resolve10({ code: exitCode, stdout: json ?? "", stderr: output });
     });
   });
 }
@@ -4355,15 +4495,15 @@ var init_kioku = __esm({
           this.snapshot.at = -Infinity;
       }
       // runs a verb that writes; fail turns kioku's refusal into a 400 with its message
-      async invoke(args, cwd, run, input) {
-        const result2 = await run(this.bin, args, cwd, input);
+      async invoke(args, cwd, run2, input) {
+        const result2 = await run2(this.bin, args, cwd, input);
         if (result2.code === 127)
           throw new KiokuError(NOT_INSTALLED, 404);
         const out = parseJson(result2.stdout);
         return { out, ok: result2.code === 0 && out !== null && !out.error, fail: (fallback) => new KiokuError(out?.error?.message ?? (tailOutput(result2.stderr, 1) || fallback), 400) };
       }
-      async change(args, cwd, run = this.write) {
-        const { out, ok, fail } = await this.invoke([...args, "--json"], cwd, run);
+      async change(args, cwd, run2 = this.write) {
+        const { out, ok, fail } = await this.invoke([...args, "--json"], cwd, run2);
         if (!ok || !out)
           throw fail(`kioku ${args.slice(0, 2).join(" ")} failed`);
         this.expire();
@@ -4437,7 +4577,7 @@ var init_kioku = __esm({
         return (await this.viewer).address;
       }
       startViewer() {
-        const started = new Promise((resolve5, reject) => {
+        const started = new Promise((resolve10, reject) => {
           const child = spawn7(this.bin, ["web", "--json", "--no-open"], { cwd: homedir5(), stdio: ["ignore", "pipe", "pipe"] });
           const lines2 = createInterface({ input: child.stdout });
           let stderr = "";
@@ -4464,7 +4604,7 @@ var init_kioku = __esm({
             if (settled || event?.event !== "listening" || !event.address?.startsWith("http://127.0.0.1:"))
               return;
             finish();
-            resolve5({ child, address: event.address });
+            resolve10({ child, address: event.address });
           });
           child.on("error", (err) => {
             const missing = err.code === "ENOENT";
@@ -4563,226 +4703,3506 @@ var init_kioku_routes = __esm({
   }
 });
 
-// ../core/dist/server.js
-import { Hono as Hono5 } from "hono";
-import { cors } from "hono/cors";
-import { join as join14, basename as basename3, resolve as resolve4 } from "node:path";
-import { readdirSync as readdirSync7, existsSync as existsSync13 } from "node:fs";
-function createForgeServer(options) {
-  const { dataDir, db: externalDb, authToken, localOnly = true } = options;
-  const dbPath = join14(dataDir, "forge.db");
-  const modulesDir = join14(dataDir, "modules");
-  const db = externalDb ?? new ForgeDB(dbPath);
-  const loader = new ModuleLoader(modulesDir, options.bundledModulesDir);
-  const runner = new ActionRunner();
-  loader.discover();
-  const app = new Hono5();
-  app.use("*", localOnly ? localOriginGuard() : cors());
-  if (authToken) {
-    app.use("/api/*", bearerAuth(authToken));
+// ../sdk/dist/define.js
+function isShellExecutor(run2) {
+  return typeof run2 === "object" && run2 !== null && run2.kind === "shell";
+}
+var SDK_VERSION, MODULE_ID_RE;
+var init_define = __esm({
+  "../sdk/dist/define.js"() {
+    "use strict";
+    SDK_VERSION = "1.0.0";
+    MODULE_ID_RE = /^[a-z][a-z0-9-]{1,31}$/;
   }
-  const cwReader = new CWReader(options.cwDir);
-  const loginManager = new LoginManager(resolveCwBin(cwReader.cwHome));
-  app.route("/api/cw", cwRoutes(cwReader, { loginManager, localOnly }));
-  app.route("/api/skills", skillRoutes(cwReader, { backupDir: join14(dataDir, "skill-backups") }));
-  const { remote, shadow, warning } = remoteClassifierFromEnv();
-  if (warning)
-    console.warn(`[state] ${warning}`);
-  const logPath = process.env.FORGE_STATE_LOG;
-  if (logPath && !remote)
-    console.warn("[state] FORGE_STATE_LOG only records remote classifier calls; set FORGE_STATE_CLASSIFIER=jev");
-  const onRemote = logPath && remote ? createStateLog(logPath, (err) => console.warn(`[state] could not write ${logPath}: ${err.message}`)) : void 0;
-  let lastStateError = "";
-  const states = new StateTracker({
-    remote,
-    shadow,
-    onRemote,
-    onError: (err) => {
-      if (err.message !== lastStateError)
-        console.warn(`[state] ${remote?.name ?? "remote"} classifier failed, using local rules: ${err.message}`);
-      lastStateError = err.message;
-    }
-  });
-  const ptyManager = new PTYManager(states);
-  const generalSessions = new GeneralSessions(join14(dataDir, "general-sessions.json"));
-  const terminalWss = createTerminalWss(ptyManager, cwReader, { localOnly, general: generalSessions });
-  app.route("/api/liveframe", liveframeRoutes());
-  const kioku = new Kioku({ projects: () => cwReader.getProjects() });
-  app.route("/api/kioku", kiokuRoutes(kioku, {
-    type: (project, sessionDir, text) => ptyManager.typeLine(project, sessionDir, text),
-    // kioku's plugin, and so its skill, exists only for Claude Code
-    canRemember: (project, sessionDir) => cwReader.getSession(project, sessionDir)?.harness === "claude"
-  }));
-  app.get("/api/cw/session-states", (c) => c.json({ classifier: states.remoteName ?? "local", shadow: states.isShadow, states: states.snapshot() }));
-  app.post("/api/cw/terminal/kill", async (c) => {
-    const { project, sessionDir } = await c.req.json();
-    const sessionId = `${project}::${sessionDir}`;
-    ptyManager.kill(sessionId);
-    generalSessions.forget(sessionId);
-    return c.json({ ok: true });
-  });
-  async function resolveAction(c) {
-    const moduleName = c.req.param("module");
-    const actionId = c.req.param("action");
-    const { projectId, cwProject, params } = await c.req.json();
-    const action = loader.getAction(moduleName, actionId);
-    if (!action) {
-      return c.json({ error: "Action not found" }, 404);
-    }
-    const checked = validateParams(action, params);
-    if ("error" in checked) {
-      return c.json({ error: checked.error }, 400);
-    }
-    let cwd;
-    if (cwProject !== void 0) {
-      const projects = cwReader.getProjects();
-      const path = Object.hasOwn(projects, cwProject) ? projects[cwProject]?.path : void 0;
-      if (!path)
-        return c.json({ error: `Unknown CW project: ${cwProject}` }, 400);
-      cwd = path;
-    } else {
-      cwd = (projectId ? db.getProject(projectId) : void 0)?.path ?? process.cwd();
-    }
-    const logId = db.logAction({
-      projectId: projectId ?? null,
-      moduleId: moduleName,
-      actionId,
-      command: action.command
-    });
-    return { action, cwd, logId, env: checked.env };
+});
+
+// ../sdk/dist/errors.js
+var PermissionError;
+var init_errors = __esm({
+  "../sdk/dist/errors.js"() {
+    "use strict";
+    PermissionError = class extends Error {
+      permission;
+      value;
+      constructor(permission, value) {
+        super(`permission ${permission} does not cover ${value}`);
+        this.name = "PermissionError";
+        this.permission = permission;
+        this.value = value;
+      }
+    };
   }
-  app.get("/api/health", (c) => {
-    return c.json({
-      status: "ok",
-      version: options.version ?? null,
-      modules: loader.getLoadedCount()
-    });
-  });
-  app.get("/api/projects", (c) => {
-    return c.json(db.listProjects());
-  });
-  app.post("/api/projects", async (c) => {
-    const { name, path } = await c.req.json();
-    const id = db.addProject({ name, path });
-    const project = db.getProject(id);
-    return c.json(project, 201);
-  });
-  app.delete("/api/projects/:id", (c) => {
-    db.removeProject(c.req.param("id"));
-    return c.json({ ok: true });
-  });
-  app.get("/api/modules", (c) => {
-    const installed = db.listModules();
-    const loaded = loader.getLoaded();
-    return c.json(installed.map((m) => ({
-      ...m,
-      manifest: loaded.get(m.name) ?? null
-    })));
-  });
-  app.get("/api/modules/available", (c) => {
-    const manifests = loader.discover();
-    return c.json(manifests);
-  });
-  app.post("/api/actions/:module/:action", async (c) => {
-    const resolved = await resolveAction(c);
-    if (resolved instanceof Response)
-      return resolved;
-    const { action, cwd, logId, env } = resolved;
-    const result2 = await runner.exec(action.command, { cwd, env });
-    db.completeAction(logId, result2.exitCode);
-    return c.json({
-      logId,
-      exitCode: result2.exitCode,
-      output: result2.output,
-      timedOut: result2.timedOut
-    });
-  });
-  app.post("/api/actions/:module/:action/stream", async (c) => {
-    const resolved = await resolveAction(c);
-    if (resolved instanceof Response)
-      return resolved;
-    const { action, cwd, logId, env } = resolved;
-    return new Response(new ReadableStream({
-      async start(controller) {
-        const encoder = new TextEncoder();
-        const send = (event, data) => {
-          controller.enqueue(encoder.encode(`event: ${event}
-data: ${JSON.stringify(data)}
+});
 
-`));
-        };
-        send("start", { logId, command: action.command });
-        const result2 = await runner.exec(action.command, {
-          cwd,
-          env,
-          onData: (chunk) => send("output", { chunk })
-        });
-        db.completeAction(logId, result2.exitCode);
-        send("done", { exitCode: result2.exitCode, timedOut: result2.timedOut });
-        controller.close();
+// ../sdk/dist/index.js
+var init_dist = __esm({
+  "../sdk/dist/index.js"() {
+    "use strict";
+    init_define();
+    init_errors();
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/internal/constants.js
+var require_constants = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/internal/constants.js"(exports, module) {
+    "use strict";
+    var SEMVER_SPEC_VERSION = "2.0.0";
+    var MAX_LENGTH = 256;
+    var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || /* istanbul ignore next */
+    9007199254740991;
+    var MAX_SAFE_COMPONENT_LENGTH = 16;
+    var MAX_SAFE_BUILD_LENGTH = MAX_LENGTH - 6;
+    var RELEASE_TYPES = [
+      "major",
+      "premajor",
+      "minor",
+      "preminor",
+      "patch",
+      "prepatch",
+      "prerelease"
+    ];
+    module.exports = {
+      MAX_LENGTH,
+      MAX_SAFE_COMPONENT_LENGTH,
+      MAX_SAFE_BUILD_LENGTH,
+      MAX_SAFE_INTEGER,
+      RELEASE_TYPES,
+      SEMVER_SPEC_VERSION,
+      FLAG_INCLUDE_PRERELEASE: 1,
+      FLAG_LOOSE: 2
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/internal/debug.js
+var require_debug = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/internal/debug.js"(exports, module) {
+    "use strict";
+    var debug = typeof process === "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG) ? (...args) => console.error("SEMVER", ...args) : () => {
+    };
+    module.exports = debug;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/internal/re.js
+var require_re = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/internal/re.js"(exports, module) {
+    "use strict";
+    var {
+      MAX_SAFE_COMPONENT_LENGTH,
+      MAX_SAFE_BUILD_LENGTH,
+      MAX_LENGTH
+    } = require_constants();
+    var debug = require_debug();
+    exports = module.exports = {};
+    var re = exports.re = [];
+    var safeRe = exports.safeRe = [];
+    var src = exports.src = [];
+    var safeSrc = exports.safeSrc = [];
+    var t = exports.t = {};
+    var R = 0;
+    var LETTERDASHNUMBER = "[a-zA-Z0-9-]";
+    var safeRegexReplacements = [
+      ["\\s", 1],
+      ["\\d", MAX_LENGTH],
+      [LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH]
+    ];
+    var makeSafeRegex = (value) => {
+      for (const [token, max] of safeRegexReplacements) {
+        value = value.split(`${token}*`).join(`${token}{0,${max}}`).split(`${token}+`).join(`${token}{1,${max}}`);
       }
-    }), {
-      headers: {
-        "Content-Type": "text/event-stream",
-        "Cache-Control": "no-cache",
-        Connection: "keep-alive"
+      return value;
+    };
+    var createToken = (name, value, isGlobal) => {
+      const safe = makeSafeRegex(value);
+      const index = R++;
+      debug(name, index, value);
+      t[name] = index;
+      src[index] = value;
+      safeSrc[index] = safe;
+      re[index] = new RegExp(value, isGlobal ? "g" : void 0);
+      safeRe[index] = new RegExp(safe, isGlobal ? "g" : void 0);
+    };
+    createToken("NUMERICIDENTIFIER", "0|[1-9]\\d*");
+    createToken("NUMERICIDENTIFIERLOOSE", "\\d+");
+    createToken("NONNUMERICIDENTIFIER", `\\d*[a-zA-Z-]${LETTERDASHNUMBER}*`);
+    createToken("MAINVERSION", `(${src[t.NUMERICIDENTIFIER]})\\.(${src[t.NUMERICIDENTIFIER]})\\.(${src[t.NUMERICIDENTIFIER]})`);
+    createToken("MAINVERSIONLOOSE", `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.(${src[t.NUMERICIDENTIFIERLOOSE]})\\.(${src[t.NUMERICIDENTIFIERLOOSE]})`);
+    createToken("PRERELEASEIDENTIFIER", `(?:${src[t.NONNUMERICIDENTIFIER]}|${src[t.NUMERICIDENTIFIER]})`);
+    createToken("PRERELEASEIDENTIFIERLOOSE", `(?:${src[t.NONNUMERICIDENTIFIER]}|${src[t.NUMERICIDENTIFIERLOOSE]})`);
+    createToken("PRERELEASE", `(?:-(${src[t.PRERELEASEIDENTIFIER]}(?:\\.${src[t.PRERELEASEIDENTIFIER]})*))`);
+    createToken("PRERELEASELOOSE", `(?:-?(${src[t.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${src[t.PRERELEASEIDENTIFIERLOOSE]})*))`);
+    createToken("BUILDIDENTIFIER", `${LETTERDASHNUMBER}+`);
+    createToken("BUILD", `(?:\\+(${src[t.BUILDIDENTIFIER]}(?:\\.${src[t.BUILDIDENTIFIER]})*))`);
+    createToken("FULLPLAIN", `v?${src[t.MAINVERSION]}${src[t.PRERELEASE]}?${src[t.BUILD]}?`);
+    createToken("FULL", `^${src[t.FULLPLAIN]}$`);
+    createToken("LOOSEPLAIN", `[v=\\s]*${src[t.MAINVERSIONLOOSE]}${src[t.PRERELEASELOOSE]}?${src[t.BUILD]}?`);
+    createToken("LOOSE", `^${src[t.LOOSEPLAIN]}$`);
+    createToken("GTLT", "((?:<|>)?=?)");
+    createToken("XRANGEIDENTIFIERLOOSE", `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`);
+    createToken("XRANGEIDENTIFIER", `${src[t.NUMERICIDENTIFIER]}|x|X|\\*`);
+    createToken("XRANGEPLAIN", `[v=\\s]*(${src[t.XRANGEIDENTIFIER]})(?:\\.(${src[t.XRANGEIDENTIFIER]})(?:\\.(${src[t.XRANGEIDENTIFIER]})(?:${src[t.PRERELEASE]})?${src[t.BUILD]}?)?)?`);
+    createToken("XRANGEPLAINLOOSE", `[v=\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})(?:${src[t.PRERELEASELOOSE]})?${src[t.BUILD]}?)?)?`);
+    createToken("XRANGE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAIN]}$`);
+    createToken("XRANGELOOSE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAINLOOSE]}$`);
+    createToken("COERCEPLAIN", `${"(^|[^\\d])(\\d{1,"}${MAX_SAFE_COMPONENT_LENGTH}})(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?`);
+    createToken("COERCE", `${src[t.COERCEPLAIN]}(?:$|[^\\d])`);
+    createToken("COERCEFULL", src[t.COERCEPLAIN] + `(?:${src[t.PRERELEASE]})?(?:${src[t.BUILD]})?(?:$|[^\\d])`);
+    createToken("COERCERTL", src[t.COERCE], true);
+    createToken("COERCERTLFULL", src[t.COERCEFULL], true);
+    createToken("LONETILDE", "(?:~>?)");
+    createToken("TILDETRIM", `(\\s*)${src[t.LONETILDE]}\\s+`, true);
+    exports.tildeTrimReplace = "$1~";
+    createToken("TILDE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAIN]}$`);
+    createToken("TILDELOOSE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAINLOOSE]}$`);
+    createToken("LONECARET", "(?:\\^)");
+    createToken("CARETTRIM", `(\\s*)${src[t.LONECARET]}\\s+`, true);
+    exports.caretTrimReplace = "$1^";
+    createToken("CARET", `^${src[t.LONECARET]}${src[t.XRANGEPLAIN]}$`);
+    createToken("CARETLOOSE", `^${src[t.LONECARET]}${src[t.XRANGEPLAINLOOSE]}$`);
+    createToken("COMPARATORLOOSE", `^${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]})$|^$`);
+    createToken("COMPARATOR", `^${src[t.GTLT]}\\s*(${src[t.FULLPLAIN]})$|^$`);
+    createToken("COMPARATORTRIM", `(\\s*)${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]}|${src[t.XRANGEPLAIN]})`, true);
+    exports.comparatorTrimReplace = "$1$2$3";
+    createToken("HYPHENRANGE", `^\\s*(${src[t.XRANGEPLAIN]})\\s+-\\s+(${src[t.XRANGEPLAIN]})\\s*$`);
+    createToken("HYPHENRANGELOOSE", `^\\s*(${src[t.XRANGEPLAINLOOSE]})\\s+-\\s+(${src[t.XRANGEPLAINLOOSE]})\\s*$`);
+    createToken("STAR", "(<|>)?=?\\s*\\*");
+    createToken("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$");
+    createToken("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$");
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/internal/parse-options.js
+var require_parse_options = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/internal/parse-options.js"(exports, module) {
+    "use strict";
+    var looseOption = Object.freeze({ loose: true });
+    var emptyOpts = Object.freeze({});
+    var parseOptions = (options) => {
+      if (!options) {
+        return emptyOpts;
       }
-    });
-  });
-  app.get("/api/action-logs", (c) => {
-    const moduleId = c.req.query("moduleId");
-    const limitStr = c.req.query("limit");
-    const limit = limitStr ? parseInt(limitStr, 10) : void 0;
-    return c.json(db.listActionLogs({ moduleId, limit }));
-  });
-  app.get("/api/modules/:module/settings", (c) => {
-    const moduleId = c.req.param("module");
-    return c.json(db.getModuleSettings(moduleId));
-  });
-  app.put("/api/modules/:module/settings", async (c) => {
-    const moduleId = c.req.param("module");
-    const body2 = await c.req.json();
-    for (const [key, value] of Object.entries(body2)) {
-      db.setModuleSetting(moduleId, key, String(value));
-    }
-    return c.json({ ok: true });
-  });
-  app.get("/api/registry/search", async (c) => {
-    const q = c.req.query("q") ?? "forge-dev";
-    try {
-      const npmRes = await globalThis.fetch(`https://registry.npmjs.org/-/v1/search?text=${encodeURIComponent(q)}+keywords:forge-module&size=20`);
-      const data = await npmRes.json();
-      const results = (data.objects ?? []).map((o) => ({
-        name: o.package.name,
-        version: o.package.version,
-        description: o.package.description
-      }));
-      return c.json({ results });
-    } catch {
-      return c.json({ results: [] });
-    }
-  });
-  app.get("/api/filesystem/browse", (c) => {
-    const home = process.env.HOME ?? "/tmp";
-    const dir = resolve4(c.req.query("path") ?? process.cwd());
-    if (!dir.startsWith(home)) {
-      return c.json({ error: "Access denied: path must be within home directory" }, 403);
-    }
-    if (!existsSync13(dir)) {
-      return c.json({ error: "Directory not found" }, 404);
-    }
-    try {
-      const entries = readdirSync7(dir, { withFileTypes: true });
-      const dirs = entries.filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => ({
-        name: e.name,
-        path: join14(dir, e.name),
-        hasPackageJson: existsSync13(join14(dir, e.name, "package.json")),
-        hasGit: existsSync13(join14(dir, e.name, ".git"))
-      })).sort((a, b) => a.name.localeCompare(b.name));
+      if (typeof options !== "object") {
+        return looseOption;
+      }
+      return options;
+    };
+    module.exports = parseOptions;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/internal/identifiers.js
+var require_identifiers = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/internal/identifiers.js"(exports, module) {
+    "use strict";
+    var numeric = /^[0-9]+$/;
+    var compareIdentifiers = (a, b) => {
+      if (typeof a === "number" && typeof b === "number") {
+        return a === b ? 0 : a < b ? -1 : 1;
+      }
+      const anum = numeric.test(a);
+      const bnum = numeric.test(b);
+      if (anum && bnum) {
+        a = +a;
+        b = +b;
+      }
+      return a === b ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a < b ? -1 : 1;
+    };
+    var rcompareIdentifiers = (a, b) => compareIdentifiers(b, a);
+    module.exports = {
+      compareIdentifiers,
+      rcompareIdentifiers
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/classes/semver.js
+var require_semver = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/classes/semver.js"(exports, module) {
+    "use strict";
+    var debug = require_debug();
+    var { MAX_LENGTH, MAX_SAFE_INTEGER } = require_constants();
+    var { safeRe: re, t } = require_re();
+    var parseOptions = require_parse_options();
+    var { compareIdentifiers } = require_identifiers();
+    var isPrereleaseIdentifier = (prerelease, identifier) => {
+      const identifiers = identifier.split(".");
+      if (identifiers.length > prerelease.length) {
+        return false;
+      }
+      for (let i = 0; i < identifiers.length; i++) {
+        if (compareIdentifiers(prerelease[i], identifiers[i]) !== 0) {
+          return false;
+        }
+      }
+      return true;
+    };
+    var SemVer = class _SemVer {
+      constructor(version, options) {
+        options = parseOptions(options);
+        if (version instanceof _SemVer) {
+          if (version.loose === !!options.loose && version.includePrerelease === !!options.includePrerelease) {
+            return version;
+          } else {
+            version = version.version;
+          }
+        } else if (typeof version !== "string") {
+          throw new TypeError(`Invalid version. Must be a string. Got type "${typeof version}".`);
+        }
+        if (version.length > MAX_LENGTH) {
+          throw new TypeError(
+            `version is longer than ${MAX_LENGTH} characters`
+          );
+        }
+        debug("SemVer", version, options);
+        this.options = options;
+        this.loose = !!options.loose;
+        this.includePrerelease = !!options.includePrerelease;
+        const m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL]);
+        if (!m) {
+          throw new TypeError(`Invalid Version: ${version}`);
+        }
+        this.raw = version;
+        this.major = +m[1];
+        this.minor = +m[2];
+        this.patch = +m[3];
+        if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
+          throw new TypeError("Invalid major version");
+        }
+        if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
+          throw new TypeError("Invalid minor version");
+        }
+        if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
+          throw new TypeError("Invalid patch version");
+        }
+        if (!m[4]) {
+          this.prerelease = [];
+        } else {
+          this.prerelease = m[4].split(".").map((id) => {
+            if (/^[0-9]+$/.test(id)) {
+              const num2 = +id;
+              if (num2 >= 0 && num2 < MAX_SAFE_INTEGER) {
+                return num2;
+              }
+            }
+            return id;
+          });
+        }
+        this.build = m[5] ? m[5].split(".") : [];
+        this.format();
+      }
+      format() {
+        this.version = `${this.major}.${this.minor}.${this.patch}`;
+        if (this.prerelease.length) {
+          this.version += `-${this.prerelease.join(".")}`;
+        }
+        return this.version;
+      }
+      toString() {
+        return this.version;
+      }
+      compare(other) {
+        debug("SemVer.compare", this.version, this.options, other);
+        if (!(other instanceof _SemVer)) {
+          if (typeof other === "string" && other === this.version) {
+            return 0;
+          }
+          other = new _SemVer(other, this.options);
+        }
+        if (other.version === this.version) {
+          return 0;
+        }
+        return this.compareMain(other) || this.comparePre(other);
+      }
+      compareMain(other) {
+        if (!(other instanceof _SemVer)) {
+          other = new _SemVer(other, this.options);
+        }
+        if (this.major < other.major) {
+          return -1;
+        }
+        if (this.major > other.major) {
+          return 1;
+        }
+        if (this.minor < other.minor) {
+          return -1;
+        }
+        if (this.minor > other.minor) {
+          return 1;
+        }
+        if (this.patch < other.patch) {
+          return -1;
+        }
+        if (this.patch > other.patch) {
+          return 1;
+        }
+        return 0;
+      }
+      comparePre(other) {
+        if (!(other instanceof _SemVer)) {
+          other = new _SemVer(other, this.options);
+        }
+        if (this.prerelease.length && !other.prerelease.length) {
+          return -1;
+        } else if (!this.prerelease.length && other.prerelease.length) {
+          return 1;
+        } else if (!this.prerelease.length && !other.prerelease.length) {
+          return 0;
+        }
+        let i = 0;
+        do {
+          const a = this.prerelease[i];
+          const b = other.prerelease[i];
+          debug("prerelease compare", i, a, b);
+          if (a === void 0 && b === void 0) {
+            return 0;
+          } else if (b === void 0) {
+            return 1;
+          } else if (a === void 0) {
+            return -1;
+          } else if (a === b) {
+            continue;
+          } else {
+            return compareIdentifiers(a, b);
+          }
+        } while (++i);
+      }
+      compareBuild(other) {
+        if (!(other instanceof _SemVer)) {
+          other = new _SemVer(other, this.options);
+        }
+        let i = 0;
+        do {
+          const a = this.build[i];
+          const b = other.build[i];
+          debug("build compare", i, a, b);
+          if (a === void 0 && b === void 0) {
+            return 0;
+          } else if (b === void 0) {
+            return 1;
+          } else if (a === void 0) {
+            return -1;
+          } else if (a === b) {
+            continue;
+          } else {
+            return compareIdentifiers(a, b);
+          }
+        } while (++i);
+      }
+      // preminor will bump the version up to the next minor release, and immediately
+      // down to pre-release. premajor and prepatch work the same way.
+      inc(release, identifier, identifierBase) {
+        if (release.startsWith("pre")) {
+          if (!identifier && identifierBase === false) {
+            throw new Error("invalid increment argument: identifier is empty");
+          }
+          if (identifier) {
+            const match = `-${identifier}`.match(this.options.loose ? re[t.PRERELEASELOOSE] : re[t.PRERELEASE]);
+            if (!match || match[1] !== identifier) {
+              throw new Error(`invalid identifier: ${identifier}`);
+            }
+          }
+        }
+        switch (release) {
+          case "premajor":
+            this.prerelease.length = 0;
+            this.patch = 0;
+            this.minor = 0;
+            this.major++;
+            this.inc("pre", identifier, identifierBase);
+            break;
+          case "preminor":
+            this.prerelease.length = 0;
+            this.patch = 0;
+            this.minor++;
+            this.inc("pre", identifier, identifierBase);
+            break;
+          case "prepatch":
+            this.prerelease.length = 0;
+            this.inc("patch", identifier, identifierBase);
+            this.inc("pre", identifier, identifierBase);
+            break;
+          // If the input is a non-prerelease version, this acts the same as
+          // prepatch.
+          case "prerelease":
+            if (this.prerelease.length === 0) {
+              this.inc("patch", identifier, identifierBase);
+            }
+            this.inc("pre", identifier, identifierBase);
+            break;
+          case "release":
+            if (this.prerelease.length === 0) {
+              throw new Error(`version ${this.raw} is not a prerelease`);
+            }
+            this.prerelease.length = 0;
+            break;
+          case "major":
+            if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) {
+              this.major++;
+            }
+            this.minor = 0;
+            this.patch = 0;
+            this.prerelease = [];
+            break;
+          case "minor":
+            if (this.patch !== 0 || this.prerelease.length === 0) {
+              this.minor++;
+            }
+            this.patch = 0;
+            this.prerelease = [];
+            break;
+          case "patch":
+            if (this.prerelease.length === 0) {
+              this.patch++;
+            }
+            this.prerelease = [];
+            break;
+          // This probably shouldn't be used publicly.
+          // 1.0.0 'pre' would become 1.0.0-0 which is the wrong direction.
+          case "pre": {
+            const base = Number(identifierBase) ? 1 : 0;
+            if (this.prerelease.length === 0) {
+              this.prerelease = [base];
+            } else {
+              let i = this.prerelease.length;
+              while (--i >= 0) {
+                if (typeof this.prerelease[i] === "number") {
+                  this.prerelease[i]++;
+                  i = -2;
+                }
+              }
+              if (i === -1) {
+                if (identifier === this.prerelease.join(".") && identifierBase === false) {
+                  throw new Error("invalid increment argument: identifier already exists");
+                }
+                this.prerelease.push(base);
+              }
+            }
+            if (identifier) {
+              let prerelease = [identifier, base];
+              if (identifierBase === false) {
+                prerelease = [identifier];
+              }
+              if (isPrereleaseIdentifier(this.prerelease, identifier)) {
+                const prereleaseBase = this.prerelease[identifier.split(".").length];
+                if (isNaN(prereleaseBase)) {
+                  this.prerelease = prerelease;
+                }
+              } else {
+                this.prerelease = prerelease;
+              }
+            }
+            break;
+          }
+          default:
+            throw new Error(`invalid increment argument: ${release}`);
+        }
+        this.raw = this.format();
+        if (this.build.length) {
+          this.raw += `+${this.build.join(".")}`;
+        }
+        return this;
+      }
+    };
+    module.exports = SemVer;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/parse.js
+var require_parse = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/parse.js"(exports, module) {
+    "use strict";
+    var SemVer = require_semver();
+    var parse = (version, options, throwErrors = false) => {
+      if (version instanceof SemVer) {
+        return version;
+      }
+      try {
+        return new SemVer(version, options);
+      } catch (er) {
+        if (!throwErrors) {
+          return null;
+        }
+        throw er;
+      }
+    };
+    module.exports = parse;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/valid.js
+var require_valid = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/valid.js"(exports, module) {
+    "use strict";
+    var parse = require_parse();
+    var valid = (version, options) => {
+      const v = parse(version, options);
+      return v ? v.version : null;
+    };
+    module.exports = valid;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/clean.js
+var require_clean = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/clean.js"(exports, module) {
+    "use strict";
+    var parse = require_parse();
+    var clean = (version, options) => {
+      const s = parse(version.trim().replace(/^[=v]+/, ""), options);
+      return s ? s.version : null;
+    };
+    module.exports = clean;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/inc.js
+var require_inc = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/inc.js"(exports, module) {
+    "use strict";
+    var SemVer = require_semver();
+    var inc = (version, release, options, identifier, identifierBase) => {
+      if (typeof options === "string") {
+        identifierBase = identifier;
+        identifier = options;
+        options = void 0;
+      }
+      try {
+        return new SemVer(
+          version instanceof SemVer ? version.version : version,
+          options
+        ).inc(release, identifier, identifierBase).version;
+      } catch (er) {
+        return null;
+      }
+    };
+    module.exports = inc;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/diff.js
+var require_diff = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/diff.js"(exports, module) {
+    "use strict";
+    var parse = require_parse();
+    var diff = (version1, version2) => {
+      const v1 = parse(version1, null, true);
+      const v2 = parse(version2, null, true);
+      const comparison = v1.compare(v2);
+      if (comparison === 0) {
+        return null;
+      }
+      const v1Higher = comparison > 0;
+      const highVersion = v1Higher ? v1 : v2;
+      const lowVersion = v1Higher ? v2 : v1;
+      const highHasPre = !!highVersion.prerelease.length;
+      const lowHasPre = !!lowVersion.prerelease.length;
+      if (lowHasPre && !highHasPre) {
+        if (!lowVersion.patch && !lowVersion.minor) {
+          return "major";
+        }
+        if (lowVersion.compareMain(highVersion) === 0) {
+          if (lowVersion.minor && !lowVersion.patch) {
+            return "minor";
+          }
+          return "patch";
+        }
+      }
+      const prefix = highHasPre ? "pre" : "";
+      if (v1.major !== v2.major) {
+        return prefix + "major";
+      }
+      if (v1.minor !== v2.minor) {
+        return prefix + "minor";
+      }
+      if (v1.patch !== v2.patch) {
+        return prefix + "patch";
+      }
+      return "prerelease";
+    };
+    module.exports = diff;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/major.js
+var require_major = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/major.js"(exports, module) {
+    "use strict";
+    var SemVer = require_semver();
+    var major = (a, loose) => new SemVer(a, loose).major;
+    module.exports = major;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/minor.js
+var require_minor = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/minor.js"(exports, module) {
+    "use strict";
+    var SemVer = require_semver();
+    var minor = (a, loose) => new SemVer(a, loose).minor;
+    module.exports = minor;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/patch.js
+var require_patch = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/patch.js"(exports, module) {
+    "use strict";
+    var SemVer = require_semver();
+    var patch = (a, loose) => new SemVer(a, loose).patch;
+    module.exports = patch;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/prerelease.js
+var require_prerelease = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/prerelease.js"(exports, module) {
+    "use strict";
+    var parse = require_parse();
+    var prerelease = (version, options) => {
+      const parsed = parse(version, options);
+      return parsed && parsed.prerelease.length ? parsed.prerelease : null;
+    };
+    module.exports = prerelease;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/compare.js
+var require_compare = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/compare.js"(exports, module) {
+    "use strict";
+    var SemVer = require_semver();
+    var compare = (a, b, loose) => new SemVer(a, loose).compare(new SemVer(b, loose));
+    module.exports = compare;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/rcompare.js
+var require_rcompare = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/rcompare.js"(exports, module) {
+    "use strict";
+    var compare = require_compare();
+    var rcompare = (a, b, loose) => compare(b, a, loose);
+    module.exports = rcompare;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/compare-loose.js
+var require_compare_loose = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/compare-loose.js"(exports, module) {
+    "use strict";
+    var compare = require_compare();
+    var compareLoose = (a, b) => compare(a, b, true);
+    module.exports = compareLoose;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/compare-build.js
+var require_compare_build = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/compare-build.js"(exports, module) {
+    "use strict";
+    var SemVer = require_semver();
+    var compareBuild = (a, b, loose) => {
+      const versionA = new SemVer(a, loose);
+      const versionB = new SemVer(b, loose);
+      return versionA.compare(versionB) || versionA.compareBuild(versionB);
+    };
+    module.exports = compareBuild;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/sort.js
+var require_sort = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/sort.js"(exports, module) {
+    "use strict";
+    var compareBuild = require_compare_build();
+    var sort = (list, loose) => list.sort((a, b) => compareBuild(a, b, loose));
+    module.exports = sort;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/rsort.js
+var require_rsort = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/rsort.js"(exports, module) {
+    "use strict";
+    var compareBuild = require_compare_build();
+    var rsort = (list, loose) => list.sort((a, b) => compareBuild(b, a, loose));
+    module.exports = rsort;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/gt.js
+var require_gt = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/gt.js"(exports, module) {
+    "use strict";
+    var compare = require_compare();
+    var gt = (a, b, loose) => compare(a, b, loose) > 0;
+    module.exports = gt;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/lt.js
+var require_lt = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/lt.js"(exports, module) {
+    "use strict";
+    var compare = require_compare();
+    var lt = (a, b, loose) => compare(a, b, loose) < 0;
+    module.exports = lt;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/eq.js
+var require_eq = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/eq.js"(exports, module) {
+    "use strict";
+    var compare = require_compare();
+    var eq = (a, b, loose) => compare(a, b, loose) === 0;
+    module.exports = eq;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/neq.js
+var require_neq = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/neq.js"(exports, module) {
+    "use strict";
+    var compare = require_compare();
+    var neq = (a, b, loose) => compare(a, b, loose) !== 0;
+    module.exports = neq;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/gte.js
+var require_gte = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/gte.js"(exports, module) {
+    "use strict";
+    var compare = require_compare();
+    var gte = (a, b, loose) => compare(a, b, loose) >= 0;
+    module.exports = gte;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/lte.js
+var require_lte = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/lte.js"(exports, module) {
+    "use strict";
+    var compare = require_compare();
+    var lte = (a, b, loose) => compare(a, b, loose) <= 0;
+    module.exports = lte;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/cmp.js
+var require_cmp = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/cmp.js"(exports, module) {
+    "use strict";
+    var eq = require_eq();
+    var neq = require_neq();
+    var gt = require_gt();
+    var gte = require_gte();
+    var lt = require_lt();
+    var lte = require_lte();
+    var cmp = (a, op, b, loose) => {
+      switch (op) {
+        case "===":
+          if (typeof a === "object") {
+            a = a.version;
+          }
+          if (typeof b === "object") {
+            b = b.version;
+          }
+          return a === b;
+        case "!==":
+          if (typeof a === "object") {
+            a = a.version;
+          }
+          if (typeof b === "object") {
+            b = b.version;
+          }
+          return a !== b;
+        case "":
+        case "=":
+        case "==":
+          return eq(a, b, loose);
+        case "!=":
+          return neq(a, b, loose);
+        case ">":
+          return gt(a, b, loose);
+        case ">=":
+          return gte(a, b, loose);
+        case "<":
+          return lt(a, b, loose);
+        case "<=":
+          return lte(a, b, loose);
+        default:
+          throw new TypeError(`Invalid operator: ${op}`);
+      }
+    };
+    module.exports = cmp;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/coerce.js
+var require_coerce = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/coerce.js"(exports, module) {
+    "use strict";
+    var SemVer = require_semver();
+    var parse = require_parse();
+    var { safeRe: re, t } = require_re();
+    var coerce = (version, options) => {
+      if (version instanceof SemVer) {
+        return version;
+      }
+      if (typeof version === "number") {
+        version = String(version);
+      }
+      if (typeof version !== "string") {
+        return null;
+      }
+      options = options || {};
+      let match = null;
+      if (!options.rtl) {
+        match = version.match(options.includePrerelease ? re[t.COERCEFULL] : re[t.COERCE]);
+      } else {
+        const coerceRtlRegex = options.includePrerelease ? re[t.COERCERTLFULL] : re[t.COERCERTL];
+        let next;
+        while ((next = coerceRtlRegex.exec(version)) && (!match || match.index + match[0].length !== version.length)) {
+          if (!match || next.index + next[0].length !== match.index + match[0].length) {
+            match = next;
+          }
+          coerceRtlRegex.lastIndex = next.index + next[1].length + next[2].length;
+        }
+        coerceRtlRegex.lastIndex = -1;
+      }
+      if (match === null) {
+        return null;
+      }
+      const major = match[2];
+      const minor = match[3] || "0";
+      const patch = match[4] || "0";
+      const prerelease = options.includePrerelease && match[5] ? `-${match[5]}` : "";
+      const build = options.includePrerelease && match[6] ? `+${match[6]}` : "";
+      return parse(`${major}.${minor}.${patch}${prerelease}${build}`, options);
+    };
+    module.exports = coerce;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/truncate.js
+var require_truncate = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/truncate.js"(exports, module) {
+    "use strict";
+    var parse = require_parse();
+    var constants3 = require_constants();
+    var SemVer = require_semver();
+    var truncate = (version, truncation, options) => {
+      if (!constants3.RELEASE_TYPES.includes(truncation)) {
+        return null;
+      }
+      const clonedVersion = cloneInputVersion(version, options);
+      return clonedVersion && doTruncation(clonedVersion, truncation);
+    };
+    var cloneInputVersion = (version, options) => {
+      const versionStringToParse = version instanceof SemVer ? version.version : version;
+      return parse(versionStringToParse, options);
+    };
+    var doTruncation = (version, truncation) => {
+      if (isPrerelease(truncation)) {
+        return version.version;
+      }
+      version.prerelease = [];
+      switch (truncation) {
+        case "major":
+          version.minor = 0;
+          version.patch = 0;
+          break;
+        case "minor":
+          version.patch = 0;
+          break;
+      }
+      return version.format();
+    };
+    var isPrerelease = (type) => {
+      return type.startsWith("pre");
+    };
+    module.exports = truncate;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/internal/lrucache.js
+var require_lrucache = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/internal/lrucache.js"(exports, module) {
+    "use strict";
+    var LRUCache = class {
+      constructor() {
+        this.max = 1e3;
+        this.map = /* @__PURE__ */ new Map();
+      }
+      get(key) {
+        const value = this.map.get(key);
+        if (value === void 0) {
+          return void 0;
+        } else {
+          this.map.delete(key);
+          this.map.set(key, value);
+          return value;
+        }
+      }
+      delete(key) {
+        return this.map.delete(key);
+      }
+      set(key, value) {
+        const deleted = this.delete(key);
+        if (!deleted && value !== void 0) {
+          if (this.map.size >= this.max) {
+            const firstKey = this.map.keys().next().value;
+            this.delete(firstKey);
+          }
+          this.map.set(key, value);
+        }
+        return this;
+      }
+    };
+    module.exports = LRUCache;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/classes/range.js
+var require_range = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/classes/range.js"(exports, module) {
+    "use strict";
+    var SPACE_CHARACTERS = /\s+/g;
+    var Range = class _Range {
+      constructor(range, options) {
+        options = parseOptions(options);
+        if (range instanceof _Range) {
+          if (range.loose === !!options.loose && range.includePrerelease === !!options.includePrerelease) {
+            return range;
+          } else {
+            return new _Range(range.raw, options);
+          }
+        }
+        if (range instanceof Comparator) {
+          this.raw = range.value;
+          this.set = [[range]];
+          this.formatted = void 0;
+          return this;
+        }
+        this.options = options;
+        this.loose = !!options.loose;
+        this.includePrerelease = !!options.includePrerelease;
+        this.raw = range.trim().replace(SPACE_CHARACTERS, " ");
+        this.set = this.raw.split("||").map((r) => this.parseRange(r.trim())).filter((c) => c.length);
+        if (!this.set.length) {
+          throw new TypeError(`Invalid SemVer Range: ${this.raw}`);
+        }
+        if (this.set.length > 1) {
+          const first = this.set[0];
+          this.set = this.set.filter((c) => !isNullSet(c[0]));
+          if (this.set.length === 0) {
+            this.set = [first];
+          } else if (this.set.length > 1) {
+            for (const c of this.set) {
+              if (c.length === 1 && isAny(c[0])) {
+                this.set = [c];
+                break;
+              }
+            }
+          }
+        }
+        this.formatted = void 0;
+      }
+      get range() {
+        if (this.formatted === void 0) {
+          this.formatted = "";
+          for (let i = 0; i < this.set.length; i++) {
+            if (i > 0) {
+              this.formatted += "||";
+            }
+            const comps = this.set[i];
+            for (let k = 0; k < comps.length; k++) {
+              if (k > 0) {
+                this.formatted += " ";
+              }
+              this.formatted += comps[k].toString().trim();
+            }
+          }
+        }
+        return this.formatted;
+      }
+      format() {
+        return this.range;
+      }
+      toString() {
+        return this.range;
+      }
+      parseRange(range) {
+        range = range.replace(BUILDSTRIPRE, "");
+        const memoOpts = (this.options.includePrerelease && FLAG_INCLUDE_PRERELEASE) | (this.options.loose && FLAG_LOOSE);
+        const memoKey = memoOpts + ":" + range;
+        const cached = cache.get(memoKey);
+        if (cached) {
+          return cached;
+        }
+        const loose = this.options.loose;
+        const hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE];
+        range = range.replace(hr, hyphenReplace(this.options.includePrerelease));
+        debug("hyphen replace", range);
+        range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace);
+        debug("comparator trim", range);
+        range = range.replace(re[t.TILDETRIM], tildeTrimReplace);
+        debug("tilde trim", range);
+        range = range.replace(re[t.CARETTRIM], caretTrimReplace);
+        debug("caret trim", range);
+        let rangeList = range.split(" ").map((comp) => parseComparator(comp, this.options)).join(" ").split(/\s+/).map((comp) => replaceGTE0(comp, this.options));
+        if (loose) {
+          rangeList = rangeList.filter((comp) => {
+            debug("loose invalid filter", comp, this.options);
+            return !!comp.match(re[t.COMPARATORLOOSE]);
+          });
+        }
+        debug("range list", rangeList);
+        const rangeMap = /* @__PURE__ */ new Map();
+        const comparators = rangeList.map((comp) => new Comparator(comp, this.options));
+        for (const comp of comparators) {
+          if (isNullSet(comp)) {
+            return [comp];
+          }
+          rangeMap.set(comp.value, comp);
+        }
+        if (rangeMap.size > 1 && rangeMap.has("")) {
+          rangeMap.delete("");
+        }
+        const result2 = [...rangeMap.values()];
+        cache.set(memoKey, result2);
+        return result2;
+      }
+      intersects(range, options) {
+        if (!(range instanceof _Range)) {
+          throw new TypeError("a Range is required");
+        }
+        return this.set.some((thisComparators) => {
+          return isSatisfiable(thisComparators, options) && range.set.some((rangeComparators) => {
+            return isSatisfiable(rangeComparators, options) && thisComparators.every((thisComparator) => {
+              return rangeComparators.every((rangeComparator) => {
+                return thisComparator.intersects(rangeComparator, options);
+              });
+            });
+          });
+        });
+      }
+      // if ANY of the sets match ALL of its comparators, then pass
+      test(version) {
+        if (!version) {
+          return false;
+        }
+        if (typeof version === "string") {
+          try {
+            version = new SemVer(version, this.options);
+          } catch (er) {
+            return false;
+          }
+        }
+        for (let i = 0; i < this.set.length; i++) {
+          if (testSet(this.set[i], version, this.options)) {
+            return true;
+          }
+        }
+        return false;
+      }
+    };
+    module.exports = Range;
+    var LRU = require_lrucache();
+    var cache = new LRU();
+    var parseOptions = require_parse_options();
+    var Comparator = require_comparator();
+    var debug = require_debug();
+    var SemVer = require_semver();
+    var {
+      safeRe: re,
+      src,
+      t,
+      comparatorTrimReplace,
+      tildeTrimReplace,
+      caretTrimReplace
+    } = require_re();
+    var { FLAG_INCLUDE_PRERELEASE, FLAG_LOOSE } = require_constants();
+    var BUILDSTRIPRE = new RegExp(src[t.BUILD], "g");
+    var isNullSet = (c) => c.value === "<0.0.0-0";
+    var isAny = (c) => c.value === "";
+    var isSatisfiable = (comparators, options) => {
+      let result2 = true;
+      const remainingComparators = comparators.slice();
+      let testComparator = remainingComparators.pop();
+      while (result2 && remainingComparators.length) {
+        result2 = remainingComparators.every((otherComparator) => {
+          return testComparator.intersects(otherComparator, options);
+        });
+        testComparator = remainingComparators.pop();
+      }
+      return result2;
+    };
+    var parseComparator = (comp, options) => {
+      comp = comp.replace(re[t.BUILD], "");
+      debug("comp", comp, options);
+      comp = replaceCarets(comp, options);
+      debug("caret", comp);
+      comp = replaceTildes(comp, options);
+      debug("tildes", comp);
+      comp = replaceXRanges(comp, options);
+      debug("xrange", comp);
+      comp = replaceStars(comp, options);
+      debug("stars", comp);
+      return comp;
+    };
+    var isX = (id) => !id || id.toLowerCase() === "x" || id === "*";
+    var invalidXRangeOrder = (M, m, p) => isX(M) && !isX(m) || isX(m) && p && !isX(p);
+    var replaceTildes = (comp, options) => {
+      return comp.trim().split(/\s+/).map((c) => replaceTilde(c, options)).join(" ");
+    };
+    var replaceTilde = (comp, options) => {
+      const r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE];
+      const z = options.includePrerelease ? "-0" : "";
+      return comp.replace(r, (_, M, m, p, pr) => {
+        debug("tilde", comp, _, M, m, p, pr);
+        let ret;
+        if (isX(M)) {
+          ret = "";
+        } else if (isX(m)) {
+          ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`;
+        } else if (isX(p)) {
+          ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`;
+        } else if (pr) {
+          debug("replaceTilde pr", pr);
+          ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;
+        } else {
+          ret = `>=${M}.${m}.${p} <${M}.${+m + 1}.0-0`;
+        }
+        debug("tilde return", ret);
+        return ret;
+      });
+    };
+    var replaceCarets = (comp, options) => {
+      return comp.trim().split(/\s+/).map((c) => replaceCaret(c, options)).join(" ");
+    };
+    var replaceCaret = (comp, options) => {
+      debug("caret", comp, options);
+      const r = options.loose ? re[t.CARETLOOSE] : re[t.CARET];
+      const z = options.includePrerelease ? "-0" : "";
+      return comp.replace(r, (_, M, m, p, pr) => {
+        debug("caret", comp, _, M, m, p, pr);
+        let ret;
+        if (isX(M)) {
+          ret = "";
+        } else if (isX(m)) {
+          ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`;
+        } else if (isX(p)) {
+          if (M === "0") {
+            ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`;
+          } else {
+            ret = `>=${M}.${m}.0${z} <${+M + 1}.0.0-0`;
+          }
+        } else if (pr) {
+          debug("replaceCaret pr", pr);
+          if (M === "0") {
+            if (m === "0") {
+              ret = `>=${M}.${m}.${p}-${pr} <${M}.${m}.${+p + 1}-0`;
+            } else {
+              ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;
+            }
+          } else {
+            ret = `>=${M}.${m}.${p}-${pr} <${+M + 1}.0.0-0`;
+          }
+        } else {
+          debug("no pr");
+          if (M === "0") {
+            if (m === "0") {
+              ret = `>=${M}.${m}.${p} <${M}.${m}.${+p + 1}-0`;
+            } else {
+              ret = `>=${M}.${m}.${p} <${M}.${+m + 1}.0-0`;
+            }
+          } else {
+            ret = `>=${M}.${m}.${p} <${+M + 1}.0.0-0`;
+          }
+        }
+        debug("caret return", ret);
+        return ret;
+      });
+    };
+    var replaceXRanges = (comp, options) => {
+      debug("replaceXRanges", comp, options);
+      return comp.split(/\s+/).map((c) => replaceXRange(c, options)).join(" ");
+    };
+    var replaceXRange = (comp, options) => {
+      comp = comp.trim();
+      const r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE];
+      return comp.replace(r, (ret, gtlt, M, m, p, pr) => {
+        debug("xRange", comp, ret, gtlt, M, m, p, pr);
+        if (invalidXRangeOrder(M, m, p)) {
+          return comp;
+        }
+        const xM = isX(M);
+        const xm = xM || isX(m);
+        const xp = xm || isX(p);
+        const anyX = xp;
+        if (gtlt === "=" && anyX) {
+          gtlt = "";
+        }
+        pr = options.includePrerelease ? "-0" : "";
+        if (xM) {
+          if (gtlt === ">" || gtlt === "<") {
+            ret = "<0.0.0-0";
+          } else {
+            ret = "*";
+          }
+        } else if (gtlt && anyX) {
+          if (xm) {
+            m = 0;
+          }
+          p = 0;
+          if (gtlt === ">") {
+            gtlt = ">=";
+            if (xm) {
+              M = +M + 1;
+              m = 0;
+              p = 0;
+            } else {
+              m = +m + 1;
+              p = 0;
+            }
+          } else if (gtlt === "<=") {
+            gtlt = "<";
+            if (xm) {
+              M = +M + 1;
+            } else {
+              m = +m + 1;
+            }
+          }
+          if (gtlt === "<") {
+            pr = "-0";
+          }
+          ret = `${gtlt + M}.${m}.${p}${pr}`;
+        } else if (xm) {
+          ret = `>=${M}.0.0${pr} <${+M + 1}.0.0-0`;
+        } else if (xp) {
+          ret = `>=${M}.${m}.0${pr} <${M}.${+m + 1}.0-0`;
+        }
+        debug("xRange return", ret);
+        return ret;
+      });
+    };
+    var replaceStars = (comp, options) => {
+      debug("replaceStars", comp, options);
+      return comp.trim().replace(re[t.STAR], "");
+    };
+    var replaceGTE0 = (comp, options) => {
+      debug("replaceGTE0", comp, options);
+      return comp.trim().replace(re[options.includePrerelease ? t.GTE0PRE : t.GTE0], "");
+    };
+    var hyphenReplace = (incPr) => ($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr) => {
+      if (isX(fM)) {
+        from = "";
+      } else if (isX(fm)) {
+        from = `>=${fM}.0.0${incPr ? "-0" : ""}`;
+      } else if (isX(fp)) {
+        from = `>=${fM}.${fm}.0${incPr ? "-0" : ""}`;
+      } else if (fpr) {
+        from = `>=${from}`;
+      } else {
+        from = `>=${from}${incPr ? "-0" : ""}`;
+      }
+      if (isX(tM)) {
+        to = "";
+      } else if (isX(tm)) {
+        to = `<${+tM + 1}.0.0-0`;
+      } else if (isX(tp)) {
+        to = `<${tM}.${+tm + 1}.0-0`;
+      } else if (tpr) {
+        to = `<=${tM}.${tm}.${tp}-${tpr}`;
+      } else if (incPr) {
+        to = `<${tM}.${tm}.${+tp + 1}-0`;
+      } else {
+        to = `<=${to}`;
+      }
+      return `${from} ${to}`.trim();
+    };
+    var testSet = (set, version, options) => {
+      for (let i = 0; i < set.length; i++) {
+        if (!set[i].test(version)) {
+          return false;
+        }
+      }
+      if (version.prerelease.length && !options.includePrerelease) {
+        for (let i = 0; i < set.length; i++) {
+          debug(set[i].semver);
+          if (set[i].semver === Comparator.ANY) {
+            continue;
+          }
+          if (set[i].semver.prerelease.length > 0) {
+            const allowed = set[i].semver;
+            if (allowed.major === version.major && allowed.minor === version.minor && allowed.patch === version.patch) {
+              return true;
+            }
+          }
+        }
+        return false;
+      }
+      return true;
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/classes/comparator.js
+var require_comparator = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/classes/comparator.js"(exports, module) {
+    "use strict";
+    var ANY = Symbol("SemVer ANY");
+    var Comparator = class _Comparator {
+      static get ANY() {
+        return ANY;
+      }
+      constructor(comp, options) {
+        options = parseOptions(options);
+        if (comp instanceof _Comparator) {
+          if (comp.loose === !!options.loose) {
+            return comp;
+          } else {
+            comp = comp.value;
+          }
+        }
+        comp = comp.trim().split(/\s+/).join(" ");
+        debug("comparator", comp, options);
+        this.options = options;
+        this.loose = !!options.loose;
+        this.parse(comp);
+        if (this.semver === ANY) {
+          this.value = "";
+        } else {
+          this.value = this.operator + this.semver.version;
+        }
+        debug("comp", this);
+      }
+      parse(comp) {
+        const r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR];
+        const m = comp.match(r);
+        if (!m) {
+          throw new TypeError(`Invalid comparator: ${comp}`);
+        }
+        this.operator = m[1] !== void 0 ? m[1] : "";
+        if (this.operator === "=") {
+          this.operator = "";
+        }
+        if (!m[2]) {
+          this.semver = ANY;
+        } else {
+          this.semver = new SemVer(m[2], this.options.loose);
+        }
+      }
+      toString() {
+        return this.value;
+      }
+      test(version) {
+        debug("Comparator.test", version, this.options.loose);
+        if (this.semver === ANY || version === ANY) {
+          return true;
+        }
+        if (typeof version === "string") {
+          try {
+            version = new SemVer(version, this.options);
+          } catch (er) {
+            return false;
+          }
+        }
+        return cmp(version, this.operator, this.semver, this.options);
+      }
+      intersects(comp, options) {
+        if (!(comp instanceof _Comparator)) {
+          throw new TypeError("a Comparator is required");
+        }
+        if (this.operator === "") {
+          if (this.value === "") {
+            return true;
+          }
+          return new Range(comp.value, options).test(this.value);
+        } else if (comp.operator === "") {
+          if (comp.value === "") {
+            return true;
+          }
+          return new Range(this.value, options).test(comp.semver);
+        }
+        options = parseOptions(options);
+        if (options.includePrerelease && (this.value === "<0.0.0-0" || comp.value === "<0.0.0-0")) {
+          return false;
+        }
+        if (!options.includePrerelease && (this.value.startsWith("<0.0.0") || comp.value.startsWith("<0.0.0"))) {
+          return false;
+        }
+        if (this.operator.startsWith(">") && comp.operator.startsWith(">")) {
+          return true;
+        }
+        if (this.operator.startsWith("<") && comp.operator.startsWith("<")) {
+          return true;
+        }
+        if (this.semver.version === comp.semver.version && this.operator.includes("=") && comp.operator.includes("=")) {
+          return true;
+        }
+        if (cmp(this.semver, "<", comp.semver, options) && this.operator.startsWith(">") && comp.operator.startsWith("<")) {
+          return true;
+        }
+        if (cmp(this.semver, ">", comp.semver, options) && this.operator.startsWith("<") && comp.operator.startsWith(">")) {
+          return true;
+        }
+        return false;
+      }
+    };
+    module.exports = Comparator;
+    var parseOptions = require_parse_options();
+    var { safeRe: re, t } = require_re();
+    var cmp = require_cmp();
+    var debug = require_debug();
+    var SemVer = require_semver();
+    var Range = require_range();
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/satisfies.js
+var require_satisfies = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/functions/satisfies.js"(exports, module) {
+    "use strict";
+    var Range = require_range();
+    var satisfies = (version, range, options) => {
+      try {
+        range = new Range(range, options);
+      } catch (er) {
+        return false;
+      }
+      return range.test(version);
+    };
+    module.exports = satisfies;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/ranges/to-comparators.js
+var require_to_comparators = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/ranges/to-comparators.js"(exports, module) {
+    "use strict";
+    var Range = require_range();
+    var toComparators = (range, options) => new Range(range, options).set.map((comp) => comp.map((c) => c.value).join(" ").trim().split(" "));
+    module.exports = toComparators;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/ranges/max-satisfying.js
+var require_max_satisfying = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/ranges/max-satisfying.js"(exports, module) {
+    "use strict";
+    var SemVer = require_semver();
+    var Range = require_range();
+    var maxSatisfying = (versions, range, options) => {
+      let max = null;
+      let maxSV = null;
+      let rangeObj = null;
+      try {
+        rangeObj = new Range(range, options);
+      } catch (er) {
+        return null;
+      }
+      versions.forEach((v) => {
+        if (rangeObj.test(v)) {
+          if (!max || maxSV.compare(v) === -1) {
+            max = v;
+            maxSV = new SemVer(max, options);
+          }
+        }
+      });
+      return max;
+    };
+    module.exports = maxSatisfying;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/ranges/min-satisfying.js
+var require_min_satisfying = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/ranges/min-satisfying.js"(exports, module) {
+    "use strict";
+    var SemVer = require_semver();
+    var Range = require_range();
+    var minSatisfying = (versions, range, options) => {
+      let min = null;
+      let minSV = null;
+      let rangeObj = null;
+      try {
+        rangeObj = new Range(range, options);
+      } catch (er) {
+        return null;
+      }
+      versions.forEach((v) => {
+        if (rangeObj.test(v)) {
+          if (!min || minSV.compare(v) === 1) {
+            min = v;
+            minSV = new SemVer(min, options);
+          }
+        }
+      });
+      return min;
+    };
+    module.exports = minSatisfying;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/ranges/min-version.js
+var require_min_version = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/ranges/min-version.js"(exports, module) {
+    "use strict";
+    var SemVer = require_semver();
+    var Range = require_range();
+    var gt = require_gt();
+    var minVersion = (range, loose) => {
+      range = new Range(range, loose);
+      let minver = new SemVer("0.0.0");
+      if (range.test(minver)) {
+        return minver;
+      }
+      minver = new SemVer("0.0.0-0");
+      if (range.test(minver)) {
+        return minver;
+      }
+      minver = null;
+      for (let i = 0; i < range.set.length; ++i) {
+        const comparators = range.set[i];
+        let setMin = null;
+        comparators.forEach((comparator) => {
+          const compver = new SemVer(comparator.semver.version);
+          switch (comparator.operator) {
+            case ">":
+              if (compver.prerelease.length === 0) {
+                compver.patch++;
+              } else {
+                compver.prerelease.push(0);
+              }
+              compver.raw = compver.format();
+            /* fallthrough */
+            case "":
+            case ">=":
+              if (!setMin || gt(compver, setMin)) {
+                setMin = compver;
+              }
+              break;
+            case "<":
+            case "<=":
+              break;
+            /* istanbul ignore next */
+            default:
+              throw new Error(`Unexpected operation: ${comparator.operator}`);
+          }
+        });
+        if (setMin && (!minver || gt(minver, setMin))) {
+          minver = setMin;
+        }
+      }
+      if (minver && range.test(minver)) {
+        return minver;
+      }
+      return null;
+    };
+    module.exports = minVersion;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/ranges/valid.js
+var require_valid2 = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/ranges/valid.js"(exports, module) {
+    "use strict";
+    var Range = require_range();
+    var validRange = (range, options) => {
+      try {
+        return new Range(range, options).range || "*";
+      } catch (er) {
+        return null;
+      }
+    };
+    module.exports = validRange;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/ranges/outside.js
+var require_outside = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/ranges/outside.js"(exports, module) {
+    "use strict";
+    var SemVer = require_semver();
+    var Comparator = require_comparator();
+    var { ANY } = Comparator;
+    var Range = require_range();
+    var satisfies = require_satisfies();
+    var gt = require_gt();
+    var lt = require_lt();
+    var lte = require_lte();
+    var gte = require_gte();
+    var outside = (version, range, hilo, options) => {
+      version = new SemVer(version, options);
+      range = new Range(range, options);
+      let gtfn, ltefn, ltfn, comp, ecomp;
+      switch (hilo) {
+        case ">":
+          gtfn = gt;
+          ltefn = lte;
+          ltfn = lt;
+          comp = ">";
+          ecomp = ">=";
+          break;
+        case "<":
+          gtfn = lt;
+          ltefn = gte;
+          ltfn = gt;
+          comp = "<";
+          ecomp = "<=";
+          break;
+        default:
+          throw new TypeError('Must provide a hilo val of "<" or ">"');
+      }
+      if (satisfies(version, range, options)) {
+        return false;
+      }
+      for (let i = 0; i < range.set.length; ++i) {
+        const comparators = range.set[i];
+        let high = null;
+        let low = null;
+        comparators.forEach((comparator) => {
+          if (comparator.semver === ANY) {
+            comparator = new Comparator(">=0.0.0");
+          }
+          high = high || comparator;
+          low = low || comparator;
+          if (gtfn(comparator.semver, high.semver, options)) {
+            high = comparator;
+          } else if (ltfn(comparator.semver, low.semver, options)) {
+            low = comparator;
+          }
+        });
+        if (high.operator === comp || high.operator === ecomp) {
+          return false;
+        }
+        if ((!low.operator || low.operator === comp) && ltefn(version, low.semver)) {
+          return false;
+        } else if (low.operator === ecomp && ltfn(version, low.semver)) {
+          return false;
+        }
+      }
+      return true;
+    };
+    module.exports = outside;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/ranges/gtr.js
+var require_gtr = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/ranges/gtr.js"(exports, module) {
+    "use strict";
+    var outside = require_outside();
+    var gtr = (version, range, options) => outside(version, range, ">", options);
+    module.exports = gtr;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/ranges/ltr.js
+var require_ltr = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/ranges/ltr.js"(exports, module) {
+    "use strict";
+    var outside = require_outside();
+    var ltr = (version, range, options) => outside(version, range, "<", options);
+    module.exports = ltr;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/ranges/intersects.js
+var require_intersects = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/ranges/intersects.js"(exports, module) {
+    "use strict";
+    var Range = require_range();
+    var intersects = (r1, r2, options) => {
+      r1 = new Range(r1, options);
+      r2 = new Range(r2, options);
+      return r1.intersects(r2, options);
+    };
+    module.exports = intersects;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/ranges/simplify.js
+var require_simplify = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/ranges/simplify.js"(exports, module) {
+    "use strict";
+    var satisfies = require_satisfies();
+    var compare = require_compare();
+    module.exports = (versions, range, options) => {
+      const set = [];
+      let first = null;
+      let prev = null;
+      const v = versions.sort((a, b) => compare(a, b, options));
+      for (const version of v) {
+        const included = satisfies(version, range, options);
+        if (included) {
+          prev = version;
+          if (!first) {
+            first = version;
+          }
+        } else {
+          if (prev) {
+            set.push([first, prev]);
+          }
+          prev = null;
+          first = null;
+        }
+      }
+      if (first) {
+        set.push([first, null]);
+      }
+      const ranges = [];
+      for (const [min, max] of set) {
+        if (min === max) {
+          ranges.push(min);
+        } else if (!max && min === v[0]) {
+          ranges.push("*");
+        } else if (!max) {
+          ranges.push(`>=${min}`);
+        } else if (min === v[0]) {
+          ranges.push(`<=${max}`);
+        } else {
+          ranges.push(`${min} - ${max}`);
+        }
+      }
+      const simplified = ranges.join(" || ");
+      const original = typeof range.raw === "string" ? range.raw : String(range);
+      return simplified.length < original.length ? simplified : range;
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/ranges/subset.js
+var require_subset = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/ranges/subset.js"(exports, module) {
+    "use strict";
+    var Range = require_range();
+    var Comparator = require_comparator();
+    var { ANY } = Comparator;
+    var satisfies = require_satisfies();
+    var compare = require_compare();
+    var subset = (sub, dom, options = {}) => {
+      if (sub === dom) {
+        return true;
+      }
+      sub = new Range(sub, options);
+      dom = new Range(dom, options);
+      let sawNonNull = false;
+      OUTER: for (const simpleSub of sub.set) {
+        for (const simpleDom of dom.set) {
+          const isSub = simpleSubset(simpleSub, simpleDom, options);
+          sawNonNull = sawNonNull || isSub !== null;
+          if (isSub) {
+            continue OUTER;
+          }
+        }
+        if (sawNonNull) {
+          return false;
+        }
+      }
+      return true;
+    };
+    var minimumVersionWithPreRelease = [new Comparator(">=0.0.0-0")];
+    var minimumVersion = [new Comparator(">=0.0.0")];
+    var simpleSubset = (sub, dom, options) => {
+      if (sub === dom) {
+        return true;
+      }
+      if (sub.length === 1 && sub[0].semver === ANY) {
+        if (dom.length === 1 && dom[0].semver === ANY) {
+          return true;
+        } else if (options.includePrerelease) {
+          sub = minimumVersionWithPreRelease;
+        } else {
+          sub = minimumVersion;
+        }
+      }
+      if (dom.length === 1 && dom[0].semver === ANY) {
+        if (options.includePrerelease) {
+          return true;
+        } else {
+          dom = minimumVersion;
+        }
+      }
+      const eqSet = /* @__PURE__ */ new Set();
+      let gt, lt;
+      for (const c of sub) {
+        if (c.operator === ">" || c.operator === ">=") {
+          gt = higherGT(gt, c, options);
+        } else if (c.operator === "<" || c.operator === "<=") {
+          lt = lowerLT(lt, c, options);
+        } else {
+          eqSet.add(c.semver);
+        }
+      }
+      if (eqSet.size > 1) {
+        return null;
+      }
+      let gtltComp;
+      if (gt && lt) {
+        gtltComp = compare(gt.semver, lt.semver, options);
+        if (gtltComp > 0) {
+          return null;
+        } else if (gtltComp === 0 && (gt.operator !== ">=" || lt.operator !== "<=")) {
+          return null;
+        }
+      }
+      for (const eq of eqSet) {
+        if (gt && !satisfies(eq, String(gt), options)) {
+          return null;
+        }
+        if (lt && !satisfies(eq, String(lt), options)) {
+          return null;
+        }
+        for (const c of dom) {
+          if (!satisfies(eq, String(c), options)) {
+            return false;
+          }
+        }
+        return true;
+      }
+      let higher, lower;
+      let hasDomLT, hasDomGT;
+      let needDomLTPre = lt && !options.includePrerelease && lt.semver.prerelease.length ? lt.semver : false;
+      let needDomGTPre = gt && !options.includePrerelease && gt.semver.prerelease.length ? gt.semver : false;
+      if (needDomLTPre && needDomLTPre.prerelease.length === 1 && lt.operator === "<" && needDomLTPre.prerelease[0] === 0) {
+        needDomLTPre = false;
+      }
+      for (const c of dom) {
+        hasDomGT = hasDomGT || c.operator === ">" || c.operator === ">=";
+        hasDomLT = hasDomLT || c.operator === "<" || c.operator === "<=";
+        if (gt) {
+          if (needDomGTPre) {
+            if (c.semver.prerelease && c.semver.prerelease.length && c.semver.major === needDomGTPre.major && c.semver.minor === needDomGTPre.minor && c.semver.patch === needDomGTPre.patch) {
+              needDomGTPre = false;
+            }
+          }
+          if (c.operator === ">" || c.operator === ">=") {
+            higher = higherGT(gt, c, options);
+            if (higher === c && higher !== gt) {
+              return false;
+            }
+          } else if (gt.operator === ">=" && !c.test(gt.semver)) {
+            return false;
+          }
+        }
+        if (lt) {
+          if (needDomLTPre) {
+            if (c.semver.prerelease && c.semver.prerelease.length && c.semver.major === needDomLTPre.major && c.semver.minor === needDomLTPre.minor && c.semver.patch === needDomLTPre.patch) {
+              needDomLTPre = false;
+            }
+          }
+          if (c.operator === "<" || c.operator === "<=") {
+            lower = lowerLT(lt, c, options);
+            if (lower === c && lower !== lt) {
+              return false;
+            }
+          } else if (lt.operator === "<=" && !c.test(lt.semver)) {
+            return false;
+          }
+        }
+        if (!c.operator && (lt || gt) && gtltComp !== 0) {
+          return false;
+        }
+      }
+      if (gt && hasDomLT && !lt && gtltComp !== 0) {
+        return false;
+      }
+      if (lt && hasDomGT && !gt && gtltComp !== 0) {
+        return false;
+      }
+      if (needDomGTPre || needDomLTPre) {
+        return false;
+      }
+      return true;
+    };
+    var higherGT = (a, b, options) => {
+      if (!a) {
+        return b;
+      }
+      const comp = compare(a.semver, b.semver, options);
+      return comp > 0 ? a : comp < 0 ? b : b.operator === ">" && a.operator === ">=" ? b : a;
+    };
+    var lowerLT = (a, b, options) => {
+      if (!a) {
+        return b;
+      }
+      const comp = compare(a.semver, b.semver, options);
+      return comp < 0 ? a : comp > 0 ? b : b.operator === "<" && a.operator === "<=" ? b : a;
+    };
+    module.exports = subset;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/index.js
+var require_semver2 = __commonJS({
+  "../../node_modules/.pnpm/semver@7.8.5/node_modules/semver/index.js"(exports, module) {
+    "use strict";
+    var internalRe = require_re();
+    var constants3 = require_constants();
+    var SemVer = require_semver();
+    var identifiers = require_identifiers();
+    var parse = require_parse();
+    var valid = require_valid();
+    var clean = require_clean();
+    var inc = require_inc();
+    var diff = require_diff();
+    var major = require_major();
+    var minor = require_minor();
+    var patch = require_patch();
+    var prerelease = require_prerelease();
+    var compare = require_compare();
+    var rcompare = require_rcompare();
+    var compareLoose = require_compare_loose();
+    var compareBuild = require_compare_build();
+    var sort = require_sort();
+    var rsort = require_rsort();
+    var gt = require_gt();
+    var lt = require_lt();
+    var eq = require_eq();
+    var neq = require_neq();
+    var gte = require_gte();
+    var lte = require_lte();
+    var cmp = require_cmp();
+    var coerce = require_coerce();
+    var truncate = require_truncate();
+    var Comparator = require_comparator();
+    var Range = require_range();
+    var satisfies = require_satisfies();
+    var toComparators = require_to_comparators();
+    var maxSatisfying = require_max_satisfying();
+    var minSatisfying = require_min_satisfying();
+    var minVersion = require_min_version();
+    var validRange = require_valid2();
+    var outside = require_outside();
+    var gtr = require_gtr();
+    var ltr = require_ltr();
+    var intersects = require_intersects();
+    var simplifyRange = require_simplify();
+    var subset = require_subset();
+    module.exports = {
+      parse,
+      valid,
+      clean,
+      inc,
+      diff,
+      major,
+      minor,
+      patch,
+      prerelease,
+      compare,
+      rcompare,
+      compareLoose,
+      compareBuild,
+      sort,
+      rsort,
+      gt,
+      lt,
+      eq,
+      neq,
+      gte,
+      lte,
+      cmp,
+      coerce,
+      truncate,
+      Comparator,
+      Range,
+      satisfies,
+      toComparators,
+      maxSatisfying,
+      minSatisfying,
+      minVersion,
+      validRange,
+      outside,
+      gtr,
+      ltr,
+      intersects,
+      simplifyRange,
+      subset,
+      SemVer,
+      re: internalRe.re,
+      src: internalRe.src,
+      tokens: internalRe.t,
+      SEMVER_SPEC_VERSION: constants3.SEMVER_SPEC_VERSION,
+      RELEASE_TYPES: constants3.RELEASE_TYPES,
+      compareIdentifiers: identifiers.compareIdentifiers,
+      rcompareIdentifiers: identifiers.rcompareIdentifiers
+    };
+  }
+});
+
+// ../core/dist/module-permissions.js
+import { realpathSync } from "node:fs";
+import { basename as basename3, dirname as dirname6, join as join14, resolve as resolve4, sep as sep2 } from "node:path";
+function expandGrants(permissions, settings) {
+  const p = permissions ?? {};
+  return {
+    network: expandAll(p.network, settings, "origin").map(normalizeOrigin).filter((o) => o !== null),
+    fsRead: expandAll(p["fs:read"], settings, "path").map(expandHome),
+    fsWrite: expandAll(p["fs:write"], settings, "path").map(expandHome),
+    shell: expandAll(p.shell, settings, "path").map(expandHome),
+    pty: p.pty === true
+  };
+}
+function expandAll(templates, settings, kind) {
+  return (templates ?? []).flatMap((t) => expandOne(t, settings, kind));
+}
+function safeValue(value, kind, atStart) {
+  if (kind === "origin")
+    return !/[/?#@\\\s]/.test(value);
+  return atStart || !value.split(/[/\\]/).includes("..");
+}
+function expandOne(template, settings, kind) {
+  const lists = /* @__PURE__ */ new Set();
+  for (const m of template.matchAll(TEMPLATE_RE))
+    if (m[2])
+      lists.add(m[1]);
+  if (lists.size > 1)
+    return [];
+  const [list] = [...lists];
+  const items = list ? Array.isArray(settings[list]) ? settings[list].map((i) => typeof i === "object" && i !== null ? i : {}) : [] : [void 0];
+  const out = [];
+  for (const item of items) {
+    let missing = false;
+    const text = template.replace(TEMPLATE_RE, (_all, key, isList, field, offset) => {
+      const v = isList ? item?.[field] : settings[key];
+      const s = typeof v === "string" ? v : typeof v === "number" && Number.isFinite(v) ? String(v) : "";
+      if (s && safeValue(s, kind, offset === 0))
+        return s;
+      missing = true;
+      return "";
+    });
+    if (!missing)
+      out.push(text);
+  }
+  return out;
+}
+function normalizeOrigin(value) {
+  try {
+    const url = new URL(value);
+    return url.username || url.password ? null : url.origin;
+  } catch {
+    return null;
+  }
+}
+function allowsOrigin(grants, target) {
+  try {
+    const url = new URL(target);
+    if (url.username || url.password)
+      return false;
+    return grants.network.includes(url.origin);
+  } catch {
+    return false;
+  }
+}
+function allowsCommand(grants, command) {
+  return grants.shell.includes(expandHome(command));
+}
+async function allowsPath(grants, target) {
+  const real = realOrParent(resolve4(expandHome(target)));
+  for (const grant of grants) {
+    const folder = grant.endsWith("/");
+    const base = realOrParent(resolve4(expandHome(grant)));
+    if (folder ? real === base || real.startsWith(base + sep2) : real === base)
+      return true;
+  }
+  return false;
+}
+function realOrParent(path) {
+  try {
+    return realpathSync(path);
+  } catch {
+    const parent = dirname6(path);
+    return parent === path ? path : join14(realOrParent(parent), basename3(path));
+  }
+}
+var TEMPLATE_RE;
+var init_module_permissions = __esm({
+  "../core/dist/module-permissions.js"() {
+    "use strict";
+    init_state_log();
+    TEMPLATE_RE = /\{([a-zA-Z0-9_]+)(\[\]\.([a-zA-Z0-9_]+))?\}/g;
+  }
+});
+
+// ../core/dist/module-manifest.js
+import { readFileSync as readFileSync10 } from "node:fs";
+import { join as join15, resolve as resolve5, sep as sep3 } from "node:path";
+function checkSdk(range, version = SDK_VERSION) {
+  if (!import_semver.default.validRange(range))
+    return `sdk range "${range}" is not valid semver`;
+  return import_semver.default.satisfies(version, range) ? null : `needs SDK ${range}, Forge has ${version}`;
+}
+function checkManifest(raw, moduleDir) {
+  if (!isObject(raw))
+    return { kind: "invalid", reason: "/: must be an object" };
+  if (raw.sdk === void 0) {
+    if (V1_FIELDS.some((f) => raw[f] !== void 0))
+      return { kind: "invalid", reason: "declares v1 fields but no sdk range" };
+    return { kind: "legacy", manifest: raw };
+  }
+  const errors = [];
+  const err = (path, message) => errors.push(`${path}: ${message}`);
+  for (const key of Object.keys(raw))
+    if (!TOP_LEVEL.has(key))
+      err(`/${key}`, "unknown field");
+  for (const key of ["id", "name", "version", "sdk", "displayName"]) {
+    if (typeof raw[key] !== "string" || raw[key] === "")
+      err(`/${key}`, "required string");
+  }
+  if (typeof raw.id === "string" && !MODULE_ID_RE.test(raw.id))
+    err("/id", `must match ${MODULE_ID_RE.source}`);
+  for (const key of ["description", "icon", "color", "server"]) {
+    if (raw[key] !== void 0 && typeof raw[key] !== "string")
+      err(`/${key}`, "must be a string");
+  }
+  if (raw.view !== void 0) {
+    if (!isObject(raw.view) || typeof raw.view.entry !== "string" || raw.view.entry === "")
+      err("/view/entry", "required string");
+    else if (raw.view.title !== void 0 && typeof raw.view.title !== "string")
+      err("/view/title", "must be a string");
+  }
+  if (raw.permissions !== void 0) {
+    if (!isObject(raw.permissions))
+      err("/permissions", "must be an object");
+    else {
+      for (const [key, value] of Object.entries(raw.permissions)) {
+        if (!PERMISSIONS.has(key))
+          err(`/permissions/${key}`, "unknown permission");
+        else if (key === "pty" ? typeof value !== "boolean" : !isStringArray(value)) {
+          err(`/permissions/${key}`, key === "pty" ? "must be a boolean" : "must be a list of strings");
+        }
+      }
+    }
+  }
+  if (raw.settings !== void 0) {
+    if (!isObject(raw.settings) || !isObject(raw.settings.schema))
+      err("/settings/schema", "required object");
+    else
+      for (const [key, def] of Object.entries(raw.settings.schema))
+        checkSettingDef(def, `/settings/schema/${key}`, true, err);
+  }
+  for (const key of ["actions", "detectors", "panels"]) {
+    if (raw[key] !== void 0 && !Array.isArray(raw[key]))
+      err(`/${key}`, "must be a list");
+  }
+  if (typeof raw.sdk === "string" && errors.length === 0) {
+    const sdkReason = checkSdk(raw.sdk);
+    if (sdkReason)
+      return { kind: "invalid", reason: sdkReason };
+  }
+  if (errors.length === 0) {
+    const entries = [["/server", raw.server], ["/view/entry", isObject(raw.view) ? raw.view.entry : void 0]];
+    for (const [path, value] of entries) {
+      if (typeof value === "string" && !insideFolder(moduleDir, value))
+        err(path, "points outside the module folder");
+    }
+  }
+  if (errors.length > 0)
+    return { kind: "invalid", reason: errors.join("; ") };
+  return { kind: "v1", manifest: raw };
+}
+function checkSettingDef(def, path, allowList, err) {
+  if (!isObject(def))
+    return err(path, "must be an object");
+  if (def.type === "list") {
+    if (!allowList)
+      return err(`${path}/type`, "lists do not nest");
+    if (!isObject(def.item))
+      return err(`${path}/item`, "required object");
+    for (const [key, sub] of Object.entries(def.item))
+      checkSettingDef(sub, `${path}/item/${key}`, false, err);
+    return;
+  }
+  if (typeof def.type !== "string" || !SCALAR_TYPES.has(def.type))
+    return err(`${path}/type`, "must be string, number, boolean, enum or list");
+  if (def.type === "enum" && !isStringArray(def.values))
+    err(`${path}/values`, "required list of strings");
+  if (def.format !== void 0 && !FORMATS.has(def.format))
+    err(`${path}/format`, "must be path, cw-project or url");
+  if (def.pattern !== void 0) {
+    try {
+      new RegExp(def.pattern);
+    } catch {
+      err(`${path}/pattern`, "is not a valid regular expression");
+    }
+  }
+}
+function insideFolder(dir, relative) {
+  const root = realOrParent(resolve5(dir));
+  const target = realOrParent(resolve5(dir, relative));
+  return target === root || target.startsWith(root + sep3);
+}
+function manifestFileFor(dir) {
+  try {
+    const pkg = JSON.parse(readFileSync10(join15(dir, "package.json"), "utf-8"));
+    const manifest = typeof pkg.forge?.manifest === "string" ? pkg.forge.manifest : "forge-module.json";
+    return { file: join15(dir, manifest), hasForgeField: pkg.forge !== void 0 };
+  } catch {
+    return { file: join15(dir, "forge-module.json"), hasForgeField: false };
+  }
+}
+function validateSettings(schema, values) {
+  const input = isObject(values) ? values : {};
+  const errors = [];
+  const value = {};
+  for (const [key, def] of Object.entries(schema)) {
+    if (def.type === "list") {
+      const raw = input[key] ?? def.default ?? [];
+      if (!Array.isArray(raw)) {
+        errors.push({ path: key, message: "must be a list" });
+        continue;
+      }
+      value[key] = raw.map((item, i) => {
+        const obj2 = isObject(item) ? item : {};
+        if (!isObject(item))
+          errors.push({ path: `${key}[${i}]`, message: "must be an object" });
+        const out = {};
+        for (const [field, sub] of Object.entries(def.item)) {
+          const v = scalar(sub, obj2[field], `${key}[${i}].${field}`, errors);
+          if (v !== void 0)
+            out[field] = v;
+        }
+        return out;
+      });
+    } else {
+      const v = scalar(def, input[key], key, errors);
+      if (v !== void 0)
+        value[key] = v;
+    }
+  }
+  return errors.length > 0 ? { ok: false, errors } : { ok: true, value };
+}
+function scalar(def, raw, path, errors) {
+  const v = raw === void 0 || raw === "" ? def.default : raw;
+  if (v === void 0) {
+    if (def.required)
+      errors.push({ path, message: "required" });
+    return void 0;
+  }
+  const fail = (message) => {
+    errors.push({ path, message });
+    return void 0;
+  };
+  switch (def.type) {
+    case "string":
+      if (typeof v !== "string")
+        return fail("must be a string");
+      if (def.pattern && !new RegExp(def.pattern).test(v))
+        return fail(`must match ${def.pattern}`);
+      return v;
+    case "number":
+      if (typeof v !== "number" || !Number.isFinite(v))
+        return fail("must be a number");
+      if (def.min !== void 0 && v < def.min)
+        return fail(`must be at least ${def.min}`);
+      if (def.max !== void 0 && v > def.max)
+        return fail(`must be at most ${def.max}`);
+      return v;
+    case "boolean":
+      return typeof v === "boolean" ? v : fail("must be a boolean");
+    case "enum":
+      return typeof v === "string" && def.values.includes(v) ? v : fail(`must be one of ${def.values.join(", ")}`);
+  }
+}
+var import_semver, V1_FIELDS, TOP_LEVEL, PERMISSIONS, SCALAR_TYPES, FORMATS, isObject, isStringArray;
+var init_module_manifest = __esm({
+  "../core/dist/module-manifest.js"() {
+    "use strict";
+    import_semver = __toESM(require_semver2(), 1);
+    init_dist();
+    init_module_permissions();
+    V1_FIELDS = ["server", "view", "permissions", "id"];
+    TOP_LEVEL = /* @__PURE__ */ new Set(["$schema", "id", "name", "version", "sdk", "displayName", "description", "icon", "color", "server", "view", "permissions", "settings", "actions", "detectors", "panels", "claude"]);
+    PERMISSIONS = /* @__PURE__ */ new Set(["network", "fs:read", "fs:write", "shell", "pty"]);
+    SCALAR_TYPES = /* @__PURE__ */ new Set(["string", "number", "boolean", "enum"]);
+    FORMATS = /* @__PURE__ */ new Set(["path", "cw-project", "url"]);
+    isObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+    isStringArray = (v) => Array.isArray(v) && v.every((x) => typeof x === "string");
+  }
+});
+
+// ../core/dist/module-context.js
+import { readFile, readdir, writeFile } from "node:fs/promises";
+import { homedir as homedir6 } from "node:os";
+function createForgeContext(deps, mod, getSettings, getGrants, onDenial) {
+  const doFetch = deps.fetch ?? globalThis.fetch;
+  const log = deps.log ?? console;
+  const deny = (permission, value) => {
+    onDenial(permission, value);
+    throw new PermissionError(permission, value);
+  };
+  const checkPath = async (permission, path) => {
+    const list = permission === "fs:read" ? getGrants().fsRead : getGrants().fsWrite;
+    if (!await allowsPath(list, path))
+      deny(permission, path);
+  };
+  const prefix = `[module ${mod.id}]`;
+  return {
+    module: mod,
+    get settings() {
+      return getSettings();
+    },
+    sessions: {
+      list: async () => deps.reader.getSpaces().map(toSessionInfo)
+    },
+    projects: {
+      list: async () => Object.entries(deps.reader.getProjects()).map(([name, p]) => ({ name, path: p.path, account: p.account })),
+      dir: async (name) => deps.reader.getProjects()[name]?.path ?? null
+    },
+    accounts: {
+      list: async () => deps.reader.getAccounts().map((name) => ({ name }))
+    },
+    git: {
+      status: async (project, sessionDir) => {
+        const session = deps.reader.getSession(project, sessionDir);
+        if (!session?.worktree)
+          return { files: [] };
+        const result2 = await deps.runner.spawn("git", ["status", "--porcelain=v1", "-b"], { cwd: session.worktree, timeout: 1e4 });
+        return result2.exitCode === 0 ? parseGitStatus(result2.output) : { files: [] };
+      }
+    },
+    storage: {
+      get: async (key) => {
+        const raw = deps.db.kvGet(mod.id, key);
+        return raw === void 0 ? void 0 : JSON.parse(raw);
+      },
+      set: async (key, value) => deps.db.kvSet(mod.id, key, JSON.stringify(value)),
+      delete: async (key) => deps.db.kvDelete(mod.id, key),
+      list: async (p) => deps.db.kvList(mod.id, p)
+    },
+    notify: {
+      attention: async (n) => {
+        deps.db.upsertNotification({ moduleId: mod.id, key: n.key, kind: "attention", title: n.title, body: n.body, version: n.version });
+      },
+      badge: async (key, count, label) => {
+        if (count <= 0)
+          return deps.db.deleteNotification(mod.id, key);
+        deps.db.upsertNotification({ moduleId: mod.id, key, kind: "badge", title: label ?? "", count, label });
+      },
+      clear: async (key) => deps.db.deleteNotification(mod.id, key)
+    },
+    fetch: async (url, init) => {
+      if (!allowsOrigin(getGrants(), url))
+        deny("network", url);
+      return doFetch(url, init);
+    },
+    fs: {
+      read: async (path) => {
+        await checkPath("fs:read", path);
+        return readFile(expandHome(path), "utf-8");
+      },
+      list: async (dir) => {
+        await checkPath("fs:read", dir.endsWith("/") ? dir : dir + "/");
+        return readdir(expandHome(dir));
+      },
+      write: async (path, data) => {
+        await checkPath("fs:write", path);
+        await writeFile(expandHome(path), data);
+      }
+    },
+    shell: {
+      exec: async (command, args, opts) => {
+        if (!allowsCommand(getGrants(), command))
+          deny("shell", command);
+        return deps.runner.spawn(expandHome(command), args, { cwd: opts?.cwd ?? homedir6(), timeout: opts?.timeoutMs });
+      }
+    },
+    pty: {
+      spawn: async (command, args, opts) => {
+        if (!getGrants().pty)
+          deny("pty", command);
+        if (!deps.spawnPty)
+          throw new Error("pty.spawn is not available in this Forge");
+        return deps.spawnPty(command, args, opts);
+      }
+    },
+    log: {
+      info: (msg) => log.info(`${prefix} ${msg}`),
+      warn: (msg) => log.warn(`${prefix} ${msg}`),
+      error: (msg) => log.error(`${prefix} ${msg}`)
+    }
+  };
+}
+function toSessionInfo(s) {
+  return {
+    project: s.project,
+    sessionDir: s.sessionDir ?? "",
+    type: s.type,
+    task: s.task,
+    account: s.account,
+    harness: s.harness,
+    provider: s.provider,
+    model: s.model,
+    worktreePath: s.worktree
+  };
+}
+function parseGitStatus(output) {
+  const lines2 = output.split("\n").filter(Boolean);
+  const status = { files: [] };
+  for (const line of lines2) {
+    if (line.startsWith("## ")) {
+      const m = /^## ([^.\s]+)(?:\.\.\.\S+)?(?: \[(?:ahead (\d+))?(?:, )?(?:behind (\d+))?\])?/.exec(line);
+      if (m) {
+        status.branch = m[1];
+        if (m[2])
+          status.ahead = Number(m[2]);
+        if (m[3])
+          status.behind = Number(m[3]);
+      }
+    } else {
+      status.files.push({ status: line.slice(0, 2).trim(), path: line.slice(3) });
+    }
+  }
+  return status;
+}
+var init_module_context = __esm({
+  "../core/dist/module-context.js"() {
+    "use strict";
+    init_dist();
+    init_module_permissions();
+    init_state_log();
+  }
+});
+
+// ../core/dist/module-host.js
+import { existsSync as existsSync13, readdirSync as readdirSync7, readFileSync as readFileSync11, statSync as statSync4, writeFileSync as writeFileSync5 } from "node:fs";
+import { basename as basename4, dirname as dirname7, join as join16, resolve as resolve6 } from "node:path";
+import { pathToFileURL } from "node:url";
+function disabled(id, c, reason, m) {
+  const text = (v, fallback) => typeof v === "string" && v ? v : fallback;
+  return { id, name: text(m?.name, id), version: text(m?.version, ""), displayName: text(m?.displayName, id), source: c.source, state: "disabled", reason };
+}
+function packages(root, source, packaged) {
+  if (!existsSync13(root))
+    return [];
+  const out = [];
+  const consider = (dir, name) => {
+    const { file, hasForgeField } = manifestFileFor(dir);
+    if (!hasForgeField && !/^@forge-dev\/mod-/.test(name))
+      return;
+    out.push({ dir, source, manifestFile: file, packaged: packaged && hasForgeField });
+  };
+  for (const entry of readdirSync7(root, { withFileTypes: true })) {
+    if (!isDir(root, entry) || entry.name.startsWith("."))
+      continue;
+    if (entry.name.startsWith("@")) {
+      for (const sub of readdirSync7(join16(root, entry.name), { withFileTypes: true })) {
+        if (isDir(join16(root, entry.name), sub))
+          consider(join16(root, entry.name, sub.name), `${entry.name}/${sub.name}`);
+      }
+    } else {
+      consider(join16(root, entry.name), entry.name);
+    }
+  }
+  return out;
+}
+function nearestPackage(dir) {
+  for (let d = dir; ; d = dirname7(d)) {
+    const path = join16(d, "package.json");
+    if (existsSync13(path)) {
+      try {
+        return { path, type: JSON.parse(readFileSync11(path, "utf-8")).type };
+      } catch {
+        return { path };
+      }
+    }
+    if (dirname7(d) === d)
+      return null;
+  }
+}
+function isDir(parent, entry) {
+  if (entry.isDirectory())
+    return true;
+  if (!entry.isSymbolicLink())
+    return false;
+  try {
+    return statSync4(join16(parent, entry.name)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function checkServer(server, m) {
+  if (typeof server !== "object" || server === null)
+    return "server.js must default-export defineModule({...})";
+  const s = server;
+  for (const key of ["routes", "actions", "jobs", "events", "detectors"]) {
+    if (s[key] !== void 0 && !Array.isArray(s[key]))
+      return `server ${key} must be a list`;
+  }
+  const dupes = (kind, ids) => {
+    const d = ids.find((id, i) => ids.indexOf(id) !== i);
+    return d ? `duplicate ${kind} ${d}` : null;
+  };
+  const shellDeclared = (m.permissions?.shell?.length ?? 0) > 0;
+  for (const action of s.actions ?? []) {
+    if (isShellExecutor(action.run) && !shellDeclared)
+      return `action ${action.id} uses shell but the manifest does not declare it`;
+    if (action.effect === "external" && typeof action.confirm !== "function")
+      return `action ${action.id} is external but has no confirm`;
+  }
+  for (const route of s.routes ?? []) {
+    const first = route.path.split("/").filter(Boolean)[0] ?? "";
+    if (RESERVED_SEGMENTS.has(first))
+      return `route ${route.path} uses a reserved segment`;
+  }
+  return dupes("action", (s.actions ?? []).map((a) => a.id)) ?? dupes("route", (s.routes ?? []).map((r) => `${r.method} ${r.path}`)) ?? dupes("job", (s.jobs ?? []).map((j) => j.id));
+}
+var RESERVED_SEGMENTS, ModuleHost;
+var init_module_host = __esm({
+  "../core/dist/module-host.js"() {
+    "use strict";
+    init_dist();
+    init_module_manifest();
+    init_module_permissions();
+    init_module_context();
+    init_modules();
+    RESERVED_SEGMENTS = /* @__PURE__ */ new Set(["settings", "actions", "view.js", "status", "notifications", "reload"]);
+    ModuleHost = class {
+      opts;
+      statuses = [];
+      loaded = /* @__PURE__ */ new Map();
+      constructor(opts) {
+        this.opts = opts;
+      }
+      list() {
+        return this.statuses;
+      }
+      get(id) {
+        return this.loaded.get(id);
+      }
+      // scans, reloads and dev changes run one at a time: each one awaits imports midway
+      queue = Promise.resolve();
+      serial(fn) {
+        const next = this.queue.then(fn, fn);
+        this.queue = next.catch(() => {
+        });
+        return next;
+      }
+      scan() {
+        return this.serial(() => this.scanNow());
+      }
+      async scanNow() {
+        for (const id of [...this.loaded.keys()])
+          this.unload(id);
+        const statuses = [];
+        const seen = /* @__PURE__ */ new Map();
+        for (const candidate of this.candidates()) {
+          const status = await this.loadCandidate(candidate, seen);
+          if (status)
+            statuses.push(status);
+        }
+        this.statuses = statuses;
+        return statuses;
+      }
+      // only this module is unloaded and loaded again; the others keep running
+      reload(id) {
+        return this.serial(() => this.reloadNow(id));
+      }
+      async reloadNow(id) {
+        const mod = this.loaded.get(id);
+        if (!mod) {
+          await this.scanNow();
+        } else {
+          this.unload(id);
+          const seen = new Map([...this.loaded.values()].map((m) => [m.status.id, m.dir]));
+          const status = await this.loadCandidate(mod.candidate, seen);
+          this.statuses = this.statuses.flatMap((s) => s === mod.status ? status ? [status] : [] : [s]);
+        }
+      }
+      addDev(path) {
+        return this.serial(() => this.addDevNow(path));
+      }
+      async addDevNow(path) {
+        const dirs = this.devDirs();
+        const dir = resolve6(path);
+        if (!dirs.includes(dir))
+          writeFileSync5(this.opts.devFile, JSON.stringify([...dirs, dir], null, 2));
+        await this.scanNow();
+        return this.statuses.find((s) => this.loaded.get(s.id)?.dir === dir) ?? this.statuses.find((s) => s.state !== "enabled" && s.id === basename4(dir));
+      }
+      removeDev(path) {
+        return this.serial(async () => {
+          const dir = resolve6(path);
+          writeFileSync5(this.opts.devFile, JSON.stringify(this.devDirs().filter((d) => d !== dir), null, 2));
+          await this.scanNow();
+        });
+      }
+      settings(id) {
+        return this.loaded.get(id)?.settings ?? {};
+      }
+      saveSettings(id, values) {
+        const mod = this.loaded.get(id);
+        if (!mod)
+          return { ok: false, errors: [{ path: "", message: "module not loaded" }] };
+        const result2 = validateSettings(mod.manifest.settings?.schema ?? {}, values);
+        if (!result2.ok)
+          return result2;
+        for (const key of Object.keys(mod.manifest.settings?.schema ?? {})) {
+          if (result2.value[key] === void 0)
+            this.opts.deps.db.deleteModuleSetting(id, key);
+          else
+            this.opts.deps.db.setModuleSetting(id, key, JSON.stringify(result2.value[key]));
+        }
+        mod.settings = result2.value;
+        mod.grants = expandGrants(mod.manifest.permissions, result2.value);
+        this.opts.hooks?.settingsChanged?.(mod);
+        return { ok: true };
+      }
+      close() {
+        for (const id of [...this.loaded.keys()])
+          this.unload(id);
+      }
+      unload(id) {
+        const mod = this.loaded.get(id);
+        if (!mod)
+          return;
+        this.opts.hooks?.unloading?.(mod);
+        mod.abort.abort();
+        this.loaded.delete(id);
+      }
+      devDirs() {
+        try {
+          const raw = JSON.parse(readFileSync11(this.opts.devFile, "utf-8"));
+          return Array.isArray(raw) ? raw.filter((d) => typeof d === "string") : [];
+        } catch {
+          return [];
+        }
+      }
+      candidates() {
+        const out = [];
+        const folder = (dir, source) => out.push({ dir, source, manifestFile: join16(dir, "forge-module.json"), packaged: false });
+        if (this.opts.bundledDir)
+          for (const name of BUNDLED_MODULES)
+            folder(join16(this.opts.bundledDir, name), "bundled");
+        for (const dir of this.devDirs())
+          folder(dir, "dev");
+        if (existsSync13(this.opts.modulesDir)) {
+          for (const entry of readdirSync7(this.opts.modulesDir, { withFileTypes: true })) {
+            if (entry.isDirectory() && entry.name !== "node_modules" && !entry.name.startsWith("."))
+              folder(join16(this.opts.modulesDir, entry.name), "installed");
+          }
+          out.push(...packages(join16(this.opts.modulesDir, "node_modules"), "node_modules", true));
+        }
+        if (this.opts.forgeNodeModules)
+          out.push(...packages(this.opts.forgeNodeModules, "node_modules", false));
+        return out;
+      }
+      async loadCandidate(c, seen) {
+        const fallbackId = basename4(c.dir);
+        if (!existsSync13(c.manifestFile)) {
+          return c.packaged ? disabled(fallbackId, c, `no manifest at ${c.manifestFile}`) : void 0;
+        }
+        let raw;
+        try {
+          raw = JSON.parse(readFileSync11(c.manifestFile, "utf-8"));
+        } catch (err) {
+          return disabled(fallbackId, c, `forge-module.json is not valid JSON: ${err.message}`);
+        }
+        const check = checkManifest(raw, c.dir);
+        const named = raw;
+        const id = typeof named.id === "string" && named.id ? named.id : fallbackId;
+        if (check.kind === "invalid")
+          return disabled(id, c, check.reason, named);
+        if (check.kind === "legacy") {
+          return { id: fallbackId, name: check.manifest.name, version: check.manifest.version, displayName: check.manifest.displayName, source: c.source, state: "legacy", icon: check.manifest.icon, color: check.manifest.color };
+        }
+        const m = check.manifest;
+        const firstFrom = seen.get(m.id);
+        if (firstFrom)
+          return disabled(m.id, c, `duplicate id, already loaded from ${firstFrom}`, m);
+        seen.set(m.id, c.dir);
+        if (!this.opts.localOnly && (m.server || m.view))
+          return disabled(m.id, c, "modules run only in local mode", m);
+        let server;
+        if (m.server) {
+          const file = resolve6(c.dir, m.server);
+          const owner = file.endsWith(".js") ? nearestPackage(dirname7(file)) : null;
+          if (owner?.type === "commonjs")
+            return disabled(m.id, c, `${m.server} is an ES module but ${owner.path} says "type": "commonjs"; add "type": "module" to the module's package.json`, m);
+          try {
+            const imported = await import(`${pathToFileURL(file).href}?v=${statSync4(file).mtimeMs}`);
+            server = imported.default;
+          } catch (err) {
+            return disabled(m.id, c, `server failed to load: ${err.message}`, m);
+          }
+          const problem = checkServer(server, m);
+          if (problem)
+            return disabled(m.id, c, problem, m);
+        }
+        const status = {
+          id: m.id,
+          name: m.name,
+          version: m.version,
+          displayName: m.displayName,
+          source: c.source,
+          state: "enabled",
+          icon: m.icon,
+          color: m.color,
+          settingsSchema: m.settings?.schema,
+          permissions: m.permissions,
+          actions: server?.actions?.map((a) => ({ id: a.id, label: a.label, effect: a.effect }))
+        };
+        if (m.view) {
+          const entry = resolve6(c.dir, m.view.entry);
+          const mtime = existsSync13(entry) ? Math.floor(statSync4(entry).mtimeMs) : 0;
+          status.view = { url: `/api/modules/${m.id}/view.js`, title: m.view.title ?? m.displayName, version: `${m.version}-${mtime}` };
+        }
+        const settings = this.readSettings(m);
+        const abort = new AbortController();
+        const mod = { status, dir: c.dir, manifest: m, server, abort, settings, candidate: c, grants: expandGrants(m.permissions, settings), ctx: void 0 };
+        mod.ctx = createForgeContext(this.opts.deps, { id: m.id, version: m.version }, () => mod.settings, () => mod.grants, (permission, value) => {
+          status.lastDenial = { permission, value, at: (/* @__PURE__ */ new Date()).toISOString() };
+        });
+        this.unload(m.id);
+        this.loaded.set(m.id, mod);
+        this.opts.hooks?.loaded?.(mod);
+        return status;
+      }
+      // stored values are JSON per key; anything unreadable falls back to the schema defaults
+      readSettings(m) {
+        const schema = m.settings?.schema ?? {};
+        const stored = {};
+        for (const [key, value] of Object.entries(this.opts.deps.db.getModuleSettings(m.id))) {
+          try {
+            stored[key] = JSON.parse(value);
+          } catch {
+          }
+        }
+        const result2 = validateSettings(schema, stored);
+        if (result2.ok)
+          return result2.value;
+        const defaults = validateSettings(schema, {});
+        return defaults.ok ? defaults.value : {};
+      }
+    };
+  }
+});
+
+// ../core/dist/module-confirmations.js
+import { createHash as createHash3, randomBytes } from "node:crypto";
+function inputHash(input) {
+  return createHash3("sha256").update(stable(input)).digest("hex");
+}
+function stable(value) {
+  if (Array.isArray(value))
+    return `[${value.map(stable).join(",")}]`;
+  if (value && typeof value === "object") {
+    return `{${Object.keys(value).sort().map((k) => `${JSON.stringify(k)}:${stable(value[k])}`).join(",")}}`;
+  }
+  return JSON.stringify(value) ?? "null";
+}
+var TTL_MS2, Confirmations;
+var init_module_confirmations = __esm({
+  "../core/dist/module-confirmations.js"() {
+    "use strict";
+    TTL_MS2 = 12e4;
+    Confirmations = class {
+      now;
+      pending = /* @__PURE__ */ new Map();
+      constructor(now = Date.now) {
+        this.now = now;
+      }
+      issue(moduleId, actionId, hash, confirmation) {
+        this.sweep();
+        const token = randomBytes(24).toString("base64url");
+        this.pending.set(token, { moduleId, actionId, hash, confirmation, expires: this.now() + TTL_MS2 });
+        return token;
+      }
+      take(token, moduleId, actionId, hash) {
+        const p = this.pending.get(token);
+        if (!p)
+          return null;
+        this.pending.delete(token);
+        if (p.expires < this.now() || p.moduleId !== moduleId || p.actionId !== actionId || p.hash !== hash)
+          return null;
+        return p.confirmation;
+      }
+      sweep() {
+        const now = this.now();
+        for (const [token, p] of this.pending)
+          if (p.expires < now)
+            this.pending.delete(token);
+      }
+    };
+  }
+});
+
+// ../core/dist/module-routes.js
+import { readFile as readFile2 } from "node:fs/promises";
+import { resolve as resolve7 } from "node:path";
+import { Hono as Hono5 } from "hono";
+function moduleRoutes(host, opts) {
+  const { db } = opts;
+  const confirmations = opts.confirmations ?? new Confirmations();
+  const app = new Hono5();
+  app.use("*", async (_c, next) => {
+    await opts.ready;
+    await next();
+  });
+  app.get("/", (c) => c.json(host.list()));
+  app.post("/rescan", async (c) => c.json(await host.scan()));
+  app.post("/dev", async (c) => {
+    const { path } = await c.req.json();
+    if (typeof path !== "string" || !path)
+      return c.json({ code: "bad_request", message: "path is required" }, 400);
+    return c.json({ status: await host.addDev(path), modules: host.list() });
+  });
+  app.delete("/dev", async (c) => {
+    const { path } = await c.req.json();
+    if (typeof path === "string")
+      await host.removeDev(path);
+    return c.json(host.list());
+  });
+  app.get("/notifications", (c) => c.json({
+    items: db.listNotifications().map((n) => ({
+      moduleId: n.moduleId,
+      key: n.key,
+      kind: n.kind,
+      title: n.title,
+      body: n.body,
+      count: n.count,
+      label: n.label,
+      seen: n.seenAt != null,
+      createdAt: n.createdAt
+    }))
+  }));
+  app.post("/:id/notifications/seen", (c) => {
+    db.markNotificationsSeen(c.req.param("id"));
+    return c.json({ ok: true });
+  });
+  app.post("/:id/reload", async (c) => {
+    await host.reload(c.req.param("id"));
+    return c.json(host.list().find((s) => s.id === c.req.param("id")) ?? removed(c.req.param("id")));
+  });
+  app.get("/:id/status", (c) => {
+    const status = host.list().find((s) => s.id === c.req.param("id"));
+    return status ? c.json(status) : c.json(removed(c.req.param("id")), 404);
+  });
+  app.get("/:id/settings", (c) => {
+    const id = c.req.param("id");
+    return c.json(host.get(id) ? host.settings(id) : db.getModuleSettings(id));
+  });
+  app.put("/:id/settings", async (c) => {
+    const id = c.req.param("id");
+    const body2 = await c.req.json();
+    if (!host.get(id)) {
+      for (const [key, value] of Object.entries(body2))
+        db.setModuleSetting(id, key, String(value));
+      return c.json({ ok: true });
+    }
+    const result2 = host.saveSettings(id, body2);
+    return result2.ok ? c.json({ ok: true }) : c.json({ errors: result2.errors }, 400);
+  });
+  app.get("/:id/view.js", async (c) => {
+    const mod = host.get(c.req.param("id"));
+    if (!mod?.manifest.view)
+      return c.json(removed(c.req.param("id")), 404);
+    try {
+      const code = await readFile2(resolve7(mod.dir, mod.manifest.view.entry), "utf-8");
+      return c.body(code, 200, { "Content-Type": "text/javascript; charset=utf-8", "Cache-Control": "no-cache" });
+    } catch (err) {
+      return c.json({ code: "not_found", message: `view bundle missing: ${err.message}` }, 404);
+    }
+  });
+  app.post("/:id/actions/:action/prepare", async (c) => {
+    const found = await findAction(c);
+    if (found instanceof Response)
+      return found;
+    const { mod, action, input } = found;
+    if (action.effect !== "external" || !action.confirm)
+      return c.json({ code: "bad_request", message: `action ${action.id} needs no confirmation` }, 400);
+    try {
+      const confirmation = await action.confirm(input, mod.ctx);
+      const token = confirmations.issue(mod.status.id, action.id, inputHash(input), confirmation);
+      const { plan: _plan, ...shown } = confirmation;
+      return c.json({ confirmation: shown, token });
+    } catch (err) {
+      return errorResponse(c, mod, err);
+    }
+  });
+  app.post("/:id/actions/:action", async (c) => {
+    const ready = await prepareRun(c);
+    if (ready instanceof Response)
+      return ready;
+    try {
+      return c.json({ result: await ready.run(() => {
+      }) ?? null });
+    } catch (err) {
+      return errorResponse(c, ready.found.mod, err);
+    }
+  });
+  app.post("/:id/actions/:action/stream", async (c) => {
+    const ready = await prepareRun(c);
+    if (ready instanceof Response)
+      return ready;
+    const { found } = ready;
+    return new Response(new ReadableStream({
+      async start(controller) {
+        const encoder = new TextEncoder();
+        const send = (event, data) => {
+          try {
+            controller.enqueue(encoder.encode(`event: ${event}
+data: ${JSON.stringify(data)}
+
+`));
+          } catch {
+          }
+        };
+        send("start", { action: found.action.id });
+        try {
+          send("done", { result: await ready.run((chunk) => send("output", { chunk })) ?? null });
+        } catch (err) {
+          send("error", describe(err));
+        }
+        try {
+          controller.close();
+        } catch {
+        }
+      }
+    }), { headers: { "Content-Type": "text/event-stream", "Cache-Control": "no-cache", Connection: "keep-alive" } });
+  });
+  app.all("/:id/*", async (c) => {
+    const id = c.req.param("id");
+    const mod = host.get(id);
+    if (!mod)
+      return c.json(removed(id), 404);
+    const path = c.req.path.slice(c.req.path.indexOf(`/${id}/`) + id.length + 1);
+    const match = matchRoute(mod.server?.routes ?? [], c.req.method, path);
+    if (!match)
+      return c.json({ code: "not_found", message: `${c.req.method} ${path} is not a route of ${id}` }, 404);
+    try {
+      const body2 = c.req.method === "GET" || c.req.method === "DELETE" ? void 0 : await readJson3(c);
+      const result2 = await match.route.handler({ params: match.params, query: c.req.query(), body: body2 }, mod.ctx);
+      return c.json(result2 ?? null);
+    } catch (err) {
+      return errorResponse(c, mod, err);
+    }
+  });
+  async function findAction(c) {
+    const id = c.req.param("id");
+    const mod = host.get(id);
+    if (!mod)
+      return c.json(removed(id), 404);
+    const action = mod.server?.actions?.find((a) => a.id === c.req.param("action"));
+    if (!action)
+      return c.json({ code: "not_found", message: `${id} has no action ${c.req.param("action")}` }, 404);
+    const body2 = await readJson3(c) ?? {};
+    let input = body2.input;
+    if (action.input) {
+      const checked = validateSettings(action.input, input);
+      if (!checked.ok)
+        return c.json({ code: "bad_request", message: "invalid input", errors: checked.errors }, 400);
+      input = checked.value;
+    }
+    return { mod, action, input, token: typeof body2.token === "string" ? body2.token : void 0 };
+  }
+  async function prepareRun(c) {
+    const found = await findAction(c);
+    if (found instanceof Response)
+      return found;
+    let confirmation;
+    if (found.action.effect === "external") {
+      confirmation = found.token ? confirmations.take(found.token, found.mod.status.id, found.action.id, inputHash(found.input)) ?? void 0 : void 0;
+      if (!confirmation)
+        return c.json({ code: "confirmation_required", message: `${found.action.label} needs a confirmation first` }, 409);
+    }
+    const logId = db.logAction({
+      projectId: null,
+      moduleId: found.mod.status.id,
+      actionId: found.action.id,
+      command: `${found.action.effect} input:${inputHash(found.input).slice(0, 12)}`
+    });
+    const signal = c.req.raw.signal;
+    return {
+      found,
+      run: async (output) => {
+        try {
+          const result2 = await run(found, confirmation, output, signal);
+          db.completeAction(logId, 0);
+          return result2;
+        } catch (err) {
+          db.completeAction(logId, 1);
+          throw err;
+        }
+      }
+    };
+  }
+  return app;
+}
+async function run(found, confirmation, output, requestSignal) {
+  const { mod, action, input } = found;
+  const signal = AbortSignal.any([mod.abort.signal, requestSignal]);
+  if (isShellExecutor(action.run)) {
+    const result2 = await mod.ctx.shell.exec(action.run.command, action.run.args);
+    output(result2.output);
+    return result2;
+  }
+  const ctx = Object.assign(Object.create(mod.ctx), { output, signal, confirmed: confirmation?.plan });
+  return action.run(input, ctx);
+}
+async function readJson3(c) {
+  const text = await c.req.text();
+  if (!text)
+    return void 0;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+}
+function removed(id) {
+  return { code: "module_removed", message: `module ${id} is not loaded` };
+}
+function describe(err) {
+  if (err instanceof PermissionError)
+    return { code: "permission", message: err.message, permission: err.permission, value: err.value };
+  const e = err;
+  const message = typeof e?.message === "string" ? e.message : String(err);
+  if (e?.name === "ModuleError" && typeof e.code === "string")
+    return { code: e.code, message };
+  return { code: "module_error", message };
+}
+function errorResponse(c, mod, err) {
+  const body2 = describe(err);
+  if (body2.code === "permission")
+    return c.json(body2, 403);
+  const status = STATUS_BY_CODE[body2.code];
+  if (status)
+    return c.json(body2, status);
+  console.error(`[module ${mod.status.id}] ${err?.stack ?? body2.message}`);
+  return c.json(body2, 500);
+}
+function matchRoute(routes, method, path) {
+  const parts = path.split("/").filter(Boolean);
+  for (const route of routes) {
+    if (route.method !== method)
+      continue;
+    const pattern = route.path.split("/").filter(Boolean);
+    if (pattern.length !== parts.length)
+      continue;
+    const params = {};
+    if (pattern.every((seg, i) => {
+      if (seg.startsWith(":")) {
+        params[seg.slice(1)] = decodeURIComponent(parts[i]);
+        return true;
+      }
+      return seg === parts[i];
+    }))
+      return { route, params };
+  }
+  return null;
+}
+var STATUS_BY_CODE;
+var init_module_routes = __esm({
+  "../core/dist/module-routes.js"() {
+    "use strict";
+    init_dist();
+    init_module_manifest();
+    init_module_confirmations();
+    STATUS_BY_CODE = {
+      bad_request: 400,
+      unauthorized: 401,
+      not_found: 404,
+      unreachable: 502,
+      upstream: 502
+    };
+  }
+});
+
+// ../core/dist/module-jobs.js
+function parseEvery(text) {
+  const m = /^(\d+)(s|m|h)$/.exec(text.trim());
+  if (!m)
+    throw new Error("every must look like 30s, 2m or 1h");
+  const ms = Number(m[1]) * UNITS[m[2]];
+  if (ms < MIN_MS)
+    throw new Error("every must be at least 30s");
+  return ms;
+}
+var MIN_MS, UNITS, JobScheduler;
+var init_module_jobs = __esm({
+  "../core/dist/module-jobs.js"() {
+    "use strict";
+    MIN_MS = 3e4;
+    UNITS = { s: 1e3, m: 6e4, h: 36e5 };
+    JobScheduler = class {
+      opts;
+      entries = /* @__PURE__ */ new Map();
+      constructor(opts) {
+        this.opts = opts;
+      }
+      start(moduleId, job, ctx) {
+        let ms;
+        try {
+          ms = parseEvery(job.every);
+        } catch (err) {
+          this.opts.onResult(moduleId, job.id, err.message);
+          return;
+        }
+        if (job.enabled && !job.enabled(ctx.settings))
+          return;
+        const entry = { lastError: null };
+        const report = (error) => {
+          if (error === entry.lastError)
+            return;
+          entry.lastError = error;
+          this.opts.onResult(moduleId, job.id, error);
+        };
+        const tick = () => {
+          if (entry.running) {
+            if (Date.now() - entry.running.startedAt < ms)
+              return;
+            entry.running.abort.abort();
+            entry.running = void 0;
+            report(`timed out after ${ms / 1e3}s`);
+          }
+          const run2 = { abort: new AbortController(), startedAt: Date.now() };
+          entry.running = run2;
+          const jobCtx = Object.assign(Object.create(ctx), { signal: run2.abort.signal });
+          Promise.resolve().then(() => job.run(jobCtx)).then(() => {
+            if (entry.running === run2) {
+              entry.running = void 0;
+              report(null);
+            }
+          }, (err) => {
+            if (entry.running === run2) {
+              entry.running = void 0;
+              report(err instanceof Error ? err.message : String(err));
+            }
+          });
+        };
+        entry.timer = setInterval(tick, ms);
+        const list = this.entries.get(moduleId) ?? [];
+        list.push(entry);
+        this.entries.set(moduleId, list);
+        tick();
+      }
+      stopModule(moduleId) {
+        for (const entry of this.entries.get(moduleId) ?? []) {
+          clearInterval(entry.timer);
+          entry.running?.abort.abort();
+          entry.running = void 0;
+        }
+        this.entries.delete(moduleId);
+      }
+    };
+  }
+});
+
+// ../core/dist/module-events.js
+var ModuleEvents;
+var init_module_events = __esm({
+  "../core/dist/module-events.js"() {
+    "use strict";
+    ModuleEvents = class {
+      opts;
+      subs = [];
+      timeoutMs;
+      constructor(opts) {
+        this.opts = opts;
+        this.timeoutMs = opts.timeoutMs ?? 1e4;
+      }
+      subscribe(moduleId, sub, ctx) {
+        this.subs.push({ moduleId, sub, ctx });
+      }
+      unsubscribeModule(moduleId) {
+        this.subs = this.subs.filter((s) => s.moduleId !== moduleId);
+      }
+      emit(name, payload) {
+        this.dispatch(this.subs.filter((s) => s.sub.event === name), name, payload);
+      }
+      emitTo(moduleId, name, payload) {
+        this.dispatch(this.subs.filter((s) => s.sub.event === name && s.moduleId === moduleId), name, payload);
+      }
+      dispatch(targets, name, payload) {
+        if (targets.length === 0)
+          return;
+        setTimeout(async () => {
+          for (const { moduleId, sub, ctx } of targets) {
+            let timer;
+            try {
+              await Promise.race([
+                Promise.resolve().then(() => sub.handler(payload, ctx)),
+                new Promise((_, reject) => {
+                  timer = setTimeout(() => reject(new Error(`timed out after ${this.timeoutMs / 1e3}s`)), this.timeoutMs);
+                })
+              ]);
+            } catch (err) {
+              this.opts.onError(moduleId, `${name}: ${err instanceof Error ? err.message : String(err)}`);
+            } finally {
+              clearTimeout(timer);
+            }
+          }
+        }, 0);
+      }
+    };
+  }
+});
+
+// ../core/dist/server.js
+import { Hono as Hono6 } from "hono";
+import { cors } from "hono/cors";
+import { join as join17, basename as basename5, resolve as resolve8 } from "node:path";
+import { readdirSync as readdirSync8, existsSync as existsSync14 } from "node:fs";
+function createForgeServer(options) {
+  const { dataDir, db: externalDb, authToken, localOnly = true } = options;
+  const dbPath = join17(dataDir, "forge.db");
+  const modulesDir = join17(dataDir, "modules");
+  const db = externalDb ?? new ForgeDB(dbPath);
+  const loader = new ModuleLoader(modulesDir, options.bundledModulesDir);
+  const runner = new ActionRunner();
+  loader.discover();
+  const app = new Hono6();
+  app.use("*", localOnly ? localOriginGuard() : cors());
+  if (authToken) {
+    app.use("/api/*", bearerAuth(authToken));
+  }
+  const cwReader = new CWReader(options.cwDir);
+  const loginManager = new LoginManager(resolveCwBin(cwReader.cwHome));
+  app.route("/api/cw", cwRoutes(cwReader, { loginManager, localOnly, events: { emit: (name, payload) => moduleEvents.emit(name, payload) } }));
+  app.route("/api/skills", skillRoutes(cwReader, { backupDir: join17(dataDir, "skill-backups") }));
+  const { remote, shadow, warning } = remoteClassifierFromEnv();
+  if (warning)
+    console.warn(`[state] ${warning}`);
+  const logPath = process.env.FORGE_STATE_LOG;
+  if (logPath && !remote)
+    console.warn("[state] FORGE_STATE_LOG only records remote classifier calls; set FORGE_STATE_CLASSIFIER=jev");
+  const onRemote = logPath && remote ? createStateLog(logPath, (err) => console.warn(`[state] could not write ${logPath}: ${err.message}`)) : void 0;
+  let lastStateError = "";
+  const states = new StateTracker({
+    remote,
+    shadow,
+    onRemote,
+    onError: (err) => {
+      if (err.message !== lastStateError)
+        console.warn(`[state] ${remote?.name ?? "remote"} classifier failed, using local rules: ${err.message}`);
+      lastStateError = err.message;
+    }
+  });
+  const ptyManager = new PTYManager(states);
+  const generalSessions = new GeneralSessions(join17(dataDir, "general-sessions.json"));
+  const terminalWss = createTerminalWss(ptyManager, cwReader, { localOnly, general: generalSessions });
+  app.route("/api/liveframe", liveframeRoutes());
+  const kioku = new Kioku({ projects: () => cwReader.getProjects() });
+  app.route("/api/kioku", kiokuRoutes(kioku, {
+    type: (project, sessionDir, text) => ptyManager.typeLine(project, sessionDir, text),
+    // kioku's plugin, and so its skill, exists only for Claude Code
+    canRemember: (project, sessionDir) => cwReader.getSession(project, sessionDir)?.harness === "claude"
+  }));
+  const jobs = new JobScheduler({
+    onResult: (id, jobId, error) => {
+      const status = moduleHost.get(id)?.status;
+      if (status)
+        status.lastJobError = error ? `${jobId}: ${error}` : void 0;
+      if (error)
+        console.warn(`[module ${id}] job ${jobId}: ${error}`);
+    }
+  });
+  const moduleEvents = new ModuleEvents({
+    onError: (id, message) => {
+      const status = moduleHost.get(id)?.status;
+      if (status)
+        status.lastEventError = message;
+      console.warn(`[module ${id}] ${message}`);
+    }
+  });
+  const startModule = (mod) => {
+    for (const job of mod.server?.jobs ?? [])
+      jobs.start(mod.status.id, job, mod.ctx);
+  };
+  const moduleHost = new ModuleHost({
+    modulesDir,
+    bundledDir: options.bundledModulesDir,
+    forgeNodeModules: options.forgeNodeModules,
+    devFile: join17(dataDir, "dev-modules.json"),
+    localOnly,
+    deps: { db, reader: cwReader, runner },
+    hooks: {
+      loaded: (mod) => {
+        for (const sub of mod.server?.events ?? [])
+          moduleEvents.subscribe(mod.status.id, sub, mod.ctx);
+        startModule(mod);
+      },
+      unloading: (mod) => {
+        jobs.stopModule(mod.status.id);
+        moduleEvents.unsubscribeModule(mod.status.id);
+      },
+      settingsChanged: (mod) => {
+        jobs.stopModule(mod.status.id);
+        startModule(mod);
+        moduleEvents.emitTo(mod.status.id, "module.settings.changed", { moduleId: mod.status.id });
+      }
+    }
+  });
+  const sessionEvent = (s) => ({
+    project: s.project,
+    sessionDir: s.sessionDir ?? "",
+    type: s.type,
+    account: s.account,
+    harness: s.harness,
+    provider: s.provider,
+    model: s.model
+  });
+  ptyManager.onLifecycle = (event, session) => moduleEvents.emit(event === "started" ? "session.started" : "session.ended", sessionEvent(session));
+  const modulesReady = moduleHost.scan().catch((err) => console.error(`[modules] scan failed: ${err.message}`));
+  app.route("/api/modules", moduleRoutes(moduleHost, { db, ready: modulesReady }));
+  app.get("/api/cw/session-states", (c) => c.json({ classifier: states.remoteName ?? "local", shadow: states.isShadow, states: states.snapshot() }));
+  app.post("/api/cw/terminal/kill", async (c) => {
+    const { project, sessionDir } = await c.req.json();
+    const sessionId = `${project}::${sessionDir}`;
+    ptyManager.kill(sessionId);
+    generalSessions.forget(sessionId);
+    return c.json({ ok: true });
+  });
+  async function resolveAction(c) {
+    const moduleName = c.req.param("module");
+    const actionId = c.req.param("action");
+    const { projectId, cwProject, params } = await c.req.json();
+    const action = loader.getAction(moduleName, actionId);
+    if (!action) {
+      return c.json({ error: "Action not found" }, 404);
+    }
+    const checked = validateParams(action, params);
+    if ("error" in checked) {
+      return c.json({ error: checked.error }, 400);
+    }
+    let cwd;
+    if (cwProject !== void 0) {
+      const projects = cwReader.getProjects();
+      const path = Object.hasOwn(projects, cwProject) ? projects[cwProject]?.path : void 0;
+      if (!path)
+        return c.json({ error: `Unknown CW project: ${cwProject}` }, 400);
+      cwd = path;
+    } else {
+      cwd = (projectId ? db.getProject(projectId) : void 0)?.path ?? process.cwd();
+    }
+    const logId = db.logAction({
+      projectId: projectId ?? null,
+      moduleId: moduleName,
+      actionId,
+      command: action.command
+    });
+    return { action, cwd, logId, env: checked.env };
+  }
+  app.get("/api/health", (c) => {
+    return c.json({
+      status: "ok",
+      version: options.version ?? null,
+      modules: loader.getLoadedCount()
+    });
+  });
+  app.get("/api/projects", (c) => {
+    return c.json(db.listProjects());
+  });
+  app.post("/api/projects", async (c) => {
+    const { name, path } = await c.req.json();
+    const id = db.addProject({ name, path });
+    const project = db.getProject(id);
+    return c.json(project, 201);
+  });
+  app.delete("/api/projects/:id", (c) => {
+    db.removeProject(c.req.param("id"));
+    return c.json({ ok: true });
+  });
+  app.get("/api/modules/available", (c) => {
+    const manifests = loader.discover();
+    return c.json(manifests);
+  });
+  app.post("/api/actions/:module/:action", async (c) => {
+    const resolved = await resolveAction(c);
+    if (resolved instanceof Response)
+      return resolved;
+    const { action, cwd, logId, env } = resolved;
+    const result2 = await runner.exec(action.command, { cwd, env });
+    db.completeAction(logId, result2.exitCode);
+    return c.json({
+      logId,
+      exitCode: result2.exitCode,
+      output: result2.output,
+      timedOut: result2.timedOut
+    });
+  });
+  app.post("/api/actions/:module/:action/stream", async (c) => {
+    const resolved = await resolveAction(c);
+    if (resolved instanceof Response)
+      return resolved;
+    const { action, cwd, logId, env } = resolved;
+    return new Response(new ReadableStream({
+      async start(controller) {
+        const encoder = new TextEncoder();
+        const send = (event, data) => {
+          controller.enqueue(encoder.encode(`event: ${event}
+data: ${JSON.stringify(data)}
+
+`));
+        };
+        send("start", { logId, command: action.command });
+        const result2 = await runner.exec(action.command, {
+          cwd,
+          env,
+          onData: (chunk) => send("output", { chunk })
+        });
+        db.completeAction(logId, result2.exitCode);
+        send("done", { exitCode: result2.exitCode, timedOut: result2.timedOut });
+        controller.close();
+      }
+    }), {
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive"
+      }
+    });
+  });
+  app.get("/api/action-logs", (c) => {
+    const moduleId = c.req.query("moduleId");
+    const limitStr = c.req.query("limit");
+    const limit = limitStr ? parseInt(limitStr, 10) : void 0;
+    return c.json(db.listActionLogs({ moduleId, limit }));
+  });
+  app.get("/api/registry/search", async (c) => {
+    const q = c.req.query("q") ?? "forge-dev";
+    try {
+      const npmRes = await globalThis.fetch(`https://registry.npmjs.org/-/v1/search?text=${encodeURIComponent(q)}+keywords:forge-module&size=20`);
+      const data = await npmRes.json();
+      const results = (data.objects ?? []).map((o) => ({
+        name: o.package.name,
+        version: o.package.version,
+        description: o.package.description
+      }));
+      return c.json({ results });
+    } catch {
+      return c.json({ results: [] });
+    }
+  });
+  app.get("/api/filesystem/browse", (c) => {
+    const home = process.env.HOME ?? "/tmp";
+    const dir = resolve8(c.req.query("path") ?? process.cwd());
+    if (!dir.startsWith(home)) {
+      return c.json({ error: "Access denied: path must be within home directory" }, 403);
+    }
+    if (!existsSync14(dir)) {
+      return c.json({ error: "Directory not found" }, 404);
+    }
+    try {
+      const entries = readdirSync8(dir, { withFileTypes: true });
+      const dirs = entries.filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => ({
+        name: e.name,
+        path: join17(dir, e.name),
+        hasPackageJson: existsSync14(join17(dir, e.name, "package.json")),
+        hasGit: existsSync14(join17(dir, e.name, ".git"))
+      })).sort((a, b) => a.name.localeCompare(b.name));
       return c.json({
         current: dir,
-        name: basename3(dir),
-        parent: join14(dir, ".."),
+        name: basename5(dir),
+        parent: join17(dir, ".."),
         directories: dirs
       });
     } catch {
@@ -4796,7 +8216,9 @@ data: ${JSON.stringify(data)}
     app,
     fetch: fetch2,
     attachTerminalWs: (server) => terminalWss.attachToServer(server),
+    modulesReady,
     close: () => {
+      moduleHost.close();
       ptyManager.dispose();
       states.dispose();
       loginManager.dispose();
@@ -4825,6 +8247,10 @@ var init_server = __esm({
     init_general_sessions();
     init_liveframe_routes();
     init_kioku_routes();
+    init_module_host();
+    init_module_routes();
+    init_module_jobs();
+    init_module_events();
     init_kioku();
   }
 });
@@ -4836,6 +8262,9 @@ __export(db_postgres_exports, {
 });
 import postgres from "postgres";
 import { randomUUID as randomUUID2 } from "node:crypto";
+function teamModeOnly() {
+  throw new Error("not available in team mode");
+}
 var PostgresDB;
 var init_db_postgres = __esm({
   "../core/dist/db-postgres.js"() {
@@ -4930,6 +8359,33 @@ var init_db_postgres = __esm({
       setModuleSetting(moduleId, key, value) {
         this.sql`INSERT INTO module_settings (module_id, key, value) VALUES (${moduleId}, ${key}, ${value}) ON CONFLICT (module_id, key) DO UPDATE SET value = EXCLUDED.value`.execute();
       }
+      deleteModuleSetting(moduleId, key) {
+        this.sql`DELETE FROM module_settings WHERE module_id = ${moduleId} AND key = ${key}`.execute();
+      }
+      kvGet(_moduleId, _key) {
+        return teamModeOnly();
+      }
+      kvSet(_moduleId, _key, _json) {
+        teamModeOnly();
+      }
+      kvDelete(_moduleId, _key) {
+        teamModeOnly();
+      }
+      kvList(_moduleId, _prefix) {
+        return teamModeOnly();
+      }
+      upsertNotification(_row) {
+        return teamModeOnly();
+      }
+      deleteNotification(_moduleId, _key) {
+        teamModeOnly();
+      }
+      listNotifications() {
+        return [];
+      }
+      markNotificationsSeen(_moduleId) {
+        teamModeOnly();
+      }
       listActionLogs(_opts) {
         throw new Error("PostgresDB.listActionLogs() not implemented \u2014 team mode is not yet supported");
       }
@@ -4948,8 +8404,8 @@ async function createDatabase(opts) {
     await db.migrate();
     return db;
   }
-  const { join: join17 } = await import("node:path");
-  return new ForgeDB(join17(opts.dataDir, "forge.db"));
+  const { join: join21 } = await import("node:path");
+  return new ForgeDB(join21(opts.dataDir, "forge.db"));
 }
 var init_db_factory = __esm({
   "../core/dist/db-factory.js"() {
@@ -4959,22 +8415,22 @@ var init_db_factory = __esm({
 });
 
 // ../core/dist/init.js
-import { existsSync as existsSync14, mkdirSync as mkdirSync5, writeFileSync as writeFileSync5 } from "node:fs";
-import { join as join15 } from "node:path";
-import { homedir as homedir6 } from "node:os";
+import { existsSync as existsSync15, mkdirSync as mkdirSync5, writeFileSync as writeFileSync6 } from "node:fs";
+import { join as join18 } from "node:path";
+import { homedir as homedir7 } from "node:os";
 function getForgeDir() {
-  return join15(homedir6(), ".forge");
+  return join18(homedir7(), ".forge");
 }
 function ensureForgeDir() {
   const forgeDir = getForgeDir();
-  if (existsSync14(forgeDir)) {
+  if (existsSync15(forgeDir)) {
     return { forgeDir, created: false };
   }
   mkdirSync5(forgeDir, { recursive: true });
   for (const d of FORGE_SUBDIRS) {
-    mkdirSync5(join15(forgeDir, d), { recursive: true });
+    mkdirSync5(join18(forgeDir, d), { recursive: true });
   }
-  writeFileSync5(join15(forgeDir, "config.json"), JSON.stringify({
+  writeFileSync6(join18(forgeDir, "config.json"), JSON.stringify({
     port: 3e3,
     theme: "dark",
     openBrowser: true,
@@ -4994,14 +8450,14 @@ var init_init = __esm({
 function waitForListening(server) {
   if (server.listening)
     return Promise.resolve();
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve10, reject) => {
     const onError = (err) => {
       server.off("listening", onListening);
       reject(err);
     };
     const onListening = () => {
       server.off("error", onError);
-      resolve5();
+      resolve10();
     };
     server.once("error", onError);
     server.once("listening", onListening);
@@ -5036,6 +8492,68 @@ var init_port_in_use = __esm({
   }
 });
 
+// ../core/dist/module-install.js
+import { existsSync as existsSync16, mkdtempSync, readFileSync as readFileSync12, rmSync as rmSync3 } from "node:fs";
+import { tmpdir } from "node:os";
+import { isAbsolute as isAbsolute2, join as join19, resolve as resolve9 } from "node:path";
+async function previewManifest(spec, opts) {
+  if (isPathSpec(spec, opts.cwd))
+    return readFolder(expand(spec, opts.cwd));
+  const tmp = mkdtempSync(join19(tmpdir(), "forge-module-pack-"));
+  try {
+    const packed = await opts.run("npm", ["pack", spec, "--pack-destination", tmp, "--ignore-scripts", "--json"], opts.cwd);
+    if (packed.code !== 0)
+      throw new Error(`npm pack ${spec} failed: ${(packed.stderr || packed.stdout).trim()}`);
+    const filename = JSON.parse(packed.stdout)[0]?.filename;
+    if (!filename)
+      throw new Error(`npm pack ${spec} produced no tarball`);
+    const untar = await opts.run("tar", ["-xzf", join19(tmp, filename), "-C", tmp], opts.cwd);
+    if (untar.code !== 0)
+      throw new Error(`could not unpack ${filename}: ${untar.stderr.trim()}`);
+    return readFolder(join19(tmp, "package"));
+  } finally {
+    rmSync3(tmp, { recursive: true, force: true });
+  }
+}
+function readFolder(dir) {
+  const manifestFile = manifestFileFor(dir).file;
+  if (!existsSync16(manifestFile))
+    throw new Error(`${dir} has no forge-module.json`);
+  const raw = JSON.parse(readFileSync12(manifestFile, "utf-8"));
+  const check = checkManifest(raw, dir);
+  if (check.kind === "invalid")
+    throw new Error(`invalid manifest: ${check.reason}`);
+  return check;
+}
+function describePermissions(manifest) {
+  const p = "permissions" in manifest ? manifest.permissions ?? {} : {};
+  const lines2 = [];
+  for (const key of ["network", "fs:read", "fs:write", "shell"]) {
+    for (const value of p[key] ?? [])
+      lines2.push(`  ${key.padEnd(9)} ${value}`);
+  }
+  if (p.pty)
+    lines2.push(`  ${"pty".padEnd(9)} yes`);
+  const legacy = "actions" in manifest && (manifest.actions ?? []).some((a) => "command" in a);
+  if (legacy)
+    lines2.push("  shell     runs the shell commands in its manifest");
+  return [lines2.length ? "It asks for:" : "It asks for no permissions.", ...lines2, "", TRUST_NOTE].join("\n");
+}
+function installArgs(spec, prefix) {
+  return ["install", "--ignore-scripts", "--prefix", prefix, spec];
+}
+var TRUST_NOTE, isPathSpec, expand;
+var init_module_install = __esm({
+  "../core/dist/module-install.js"() {
+    "use strict";
+    init_module_manifest();
+    init_state_log();
+    TRUST_NOTE = "Modules run inside Forge with your access. Forge checks every call against these permissions, but it is not a sandbox: install only modules you trust.";
+    isPathSpec = (spec, cwd) => spec.startsWith(".") || spec.startsWith("~") || isAbsolute2(spec) || existsSync16(resolve9(cwd, spec)) && !spec.startsWith("@");
+    expand = (spec, cwd) => resolve9(cwd, expandHome(spec));
+  }
+});
+
 // ../core/dist/index.js
 var dist_exports = {};
 __export(dist_exports, {
@@ -5053,18 +8571,23 @@ __export(dist_exports, {
   ModuleLoader: () => ModuleLoader,
   PROVIDER_NAME_RE: () => PROVIDER_NAME_RE,
   PTYManager: () => PTYManager,
+  TRUST_NOTE: () => TRUST_NOTE,
   bearerAuth: () => bearerAuth,
   createDatabase: () => createDatabase,
   createForgeServer: () => createForgeServer,
+  createRunner: () => createRunner,
   createTerminalWss: () => createTerminalWss,
   cwRoutes: () => cwRoutes,
+  describePermissions: () => describePermissions,
   ensureCw: () => ensureCw,
   ensureForgeDir: () => ensureForgeDir,
   getForgeDir: () => getForgeDir,
+  installArgs: () => installArgs,
   kiokuRoutes: () => kiokuRoutes,
   liveframeRoutes: () => liveframeRoutes,
   pathWithCw: () => pathWithCw,
   portInUseMessage: () => portInUseMessage,
+  previewManifest: () => previewManifest,
   probePort: () => probePort,
   quietSqliteWarning: () => quietSqliteWarning,
   rememberPrompt: () => rememberPrompt,
@@ -5075,7 +8598,7 @@ __export(dist_exports, {
   validateParams: () => validateParams,
   waitForListening: () => waitForListening
 });
-var init_dist = __esm({
+var init_dist2 = __esm({
   "../core/dist/index.js"() {
     "use strict";
     init_server();
@@ -5100,13 +8623,15 @@ var init_dist = __esm({
     init_kioku_routes();
     init_kioku();
     init_port_in_use();
+    init_module_install();
+    init_task_review();
   }
 });
 
 // src/index.ts
-import { existsSync as existsSync15, readFileSync as readFileSync10 } from "node:fs";
-import { homedir as homedir7 } from "node:os";
-import { join as join16 } from "node:path";
+import { existsSync as existsSync17, readFileSync as readFileSync13 } from "node:fs";
+import { homedir as homedir8 } from "node:os";
+import { join as join20 } from "node:path";
 function parseArgs(argv) {
   const out = { open: true };
   for (let i = 0; i < argv.length; i++) {
@@ -5117,21 +8642,21 @@ function parseArgs(argv) {
   }
   return out;
 }
-var packageRoot = join16(import.meta.dirname, "..");
-var isCheckout = existsSync15(join16(packageRoot, "src"));
-var consoleDist = isCheckout ? join16(packageRoot, "../console/dist") : join16(packageRoot, "console");
-var forgeVersion = JSON.parse(readFileSync10(join16(packageRoot, "package.json"), "utf-8")).version;
-var bundledModulesDir = isCheckout ? join16(packageRoot, "../../modules") : join16(packageRoot, "modules");
+var packageRoot = join20(import.meta.dirname, "..");
+var isCheckout = existsSync17(join20(packageRoot, "src"));
+var consoleDist = isCheckout ? join20(packageRoot, "../console/dist") : join20(packageRoot, "console");
+var forgeVersion = JSON.parse(readFileSync13(join20(packageRoot, "package.json"), "utf-8")).version;
+var bundledModulesDir = isCheckout ? join20(packageRoot, "../../modules") : join20(packageRoot, "modules");
 async function main() {
-  const { ensureForgeDir: ensureForgeDir2, createForgeServer: createForgeServer2, createDatabase: createDatabase2, resolveListenOptions: resolveListenOptions2, ensureCw: ensureCw2, pathWithCw: pathWithCw2, quietSqliteWarning: quietSqliteWarning2, waitForListening: waitForListening2, probePort: probePort2, portInUseMessage: portInUseMessage2 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
+  const { ensureForgeDir: ensureForgeDir2, createForgeServer: createForgeServer2, createDatabase: createDatabase2, resolveListenOptions: resolveListenOptions2, ensureCw: ensureCw2, pathWithCw: pathWithCw2, quietSqliteWarning: quietSqliteWarning2, waitForListening: waitForListening2, probePort: probePort2, portInUseMessage: portInUseMessage2 } = await Promise.resolve().then(() => (init_dist2(), dist_exports));
   quietSqliteWarning2();
   const args = parseArgs(process.argv.slice(2));
   const { forgeDir, created } = ensureForgeDir2();
   if (created) {
     console.log("First run \u2014 initialized Forge.");
   }
-  const cwHome = join16(process.env.HOME ?? homedir7(), ".cw");
-  const cw = isCheckout ? { action: "skipped", message: "a checkout does not install CW" } : await ensureCw2({ cwHome, bundleDir: join16(packageRoot, "cw") });
+  const cwHome = join20(process.env.HOME ?? homedir8(), ".cw");
+  const cw = isCheckout ? { action: "skipped", message: "a checkout does not install CW" } : await ensureCw2({ cwHome, bundleDir: join20(packageRoot, "cw") });
   if (cw.action === "installed") console.log(`  Installed CW ${cw.version} in ${cwHome}`);
   else if (cw.action === "updated") console.log(`  Updated ${cw.message}`);
   else if (cw.action === "failed") console.log(`  Could not install CW: ${cw.message}`);
@@ -5156,9 +8681,9 @@ async function main() {
     version: forgeVersion
   });
   const { serveStatic } = await import("@hono/node-server/serve-static");
-  if (existsSync15(join16(consoleDist, "index.html"))) {
+  if (existsSync17(join20(consoleDist, "index.html"))) {
     server.app.use("/*", serveStatic({ root: consoleDist }));
-    const indexHtml = readFileSync10(join16(consoleDist, "index.html"), "utf-8");
+    const indexHtml = readFileSync13(join20(consoleDist, "index.html"), "utf-8");
     server.app.get("*", (c) => c.html(indexHtml));
   }
   const { serve } = await import("@hono/node-server");