forge-cw 0.1.7 → 0.1.9

package/dist/index.js

@@ -814,6 +814,14 @@ var init_cw_types = __esm({
 import { execFile } from "node:child_process";
 import { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
 import { join as join3 } from "node:path";
+function envWithoutHost(env = process.env) {
+  const out = {};
+  for (const [key, value] of Object.entries(env)) {
+    if (value !== void 0 && key !== "CLAUDECODE" && !key.startsWith("CLAUDE_CODE_"))
+      out[key] = value;
+  }
+  return out;
+}
 function envWithoutHarness(env = process.env) {
   const out = {};
   for (const [key, value] of Object.entries(env)) {
@@ -940,8 +948,8 @@ function closeWarningsFor(input) {
   return warnings;
 }
 function createRunner(env, timeoutMs = COMMAND_TIMEOUT_MS) {
-  return (bin, args, cwd) => new Promise((resolve5) => {
-    execFile2(bin, args, { cwd, env, timeout: timeoutMs, maxBuffer: 5 * 1024 * 1024 }, (err, stdout, stderr) => {
+  return (bin, args, cwd, input) => new Promise((resolve5) => {
+    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) });
       const { code } = err;
@@ -949,6 +957,11 @@ function createRunner(env, timeoutMs = COMMAND_TIMEOUT_MS) {
         return resolve5({ code: 127, stdout: "", stderr: "ENOENT" });
       resolve5({ code: typeof code === "number" ? code : 1, stdout: String(stdout), stderr: String(stderr) || err.message });
     });
+    if (input !== void 0) {
+      child.stdin?.on("error", () => {
+      });
+      child.stdin?.end(input);
+    }
   });
 }
 function isCwLink(worktree, porcelainLine) {
@@ -1526,9 +1539,9 @@ var init_login_manager = __esm({
       cwBin;
       spawn;
       entries = /* @__PURE__ */ new Map();
-      constructor(cwBin, spawn7 = spawnInPty) {
+      constructor(cwBin, spawn8 = spawnInPty) {
         this.cwBin = cwBin;
-        this.spawn = spawn7;
+        this.spawn = spawn8;
       }
       start(account, harness) {
         const key = `${account}::${harness}`;
@@ -3144,6 +3157,15 @@ var init_pty_manager = __esm({
       get(sessionId) {
         return this.sessions.get(sessionId);
       }
+      // types a line into a live session, then Enter apart, so the agent's prompt takes it as typed and not as a paste
+      typeLine(project, sessionDir, text) {
+        const session = this.sessions.get(this.makeKey(project, sessionDir));
+        if (!session)
+          return false;
+        session.pty.write(text);
+        setTimeout(() => session.pty.write("\r"), 150);
+        return true;
+      }
       // the state tracker reads the screen at the size the user sees it
       resize(sessionId, cols, rows) {
         const session = this.sessions.get(sessionId);
@@ -3932,20 +3954,458 @@ var init_liveframe_routes = __esm({
   }
 });
 
-// ../core/dist/server.js
+// ../core/dist/cw-install.js
+import { execFile as execFile5 } from "node:child_process";
+import { createHash as createHash2 } from "node:crypto";
+import { accessSync as accessSync2, constants as constants2, existsSync as existsSync11, readFileSync as readFileSync9, statSync as statSync3, writeFileSync as writeFileSync4 } from "node:fs";
+import { delimiter as delimiter2, join as join12 } from "node:path";
+function readCwVersion(file) {
+  try {
+    const match = /^CW_VERSION="([^"]+)"/m.exec(readFileSync9(file, "utf-8"));
+    return match ? match[1] : null;
+  } catch {
+    return null;
+  }
+}
+function compareVersions(a, b) {
+  const pa = a.split(".").map((n) => parseInt(n, 10) || 0);
+  const pb = b.split(".").map((n) => parseInt(n, 10) || 0);
+  for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+    const diff = (pa[i] ?? 0) - (pb[i] ?? 0);
+    if (diff !== 0)
+      return diff;
+  }
+  return 0;
+}
+function readCwBundle(dir) {
+  try {
+    const { ref } = JSON.parse(readFileSync9(join12(dir, ".bundle.json"), "utf-8"));
+    const version = readCwVersion(join12(dir, "cw"));
+    if (!ref || !version || !existsSync11(join12(dir, "install.sh")))
+      return null;
+    return { dir, version, ref };
+  } catch {
+    return null;
+  }
+}
+function decideCwInstall({ bundle, installed, marker, cwOnPath, skip }) {
+  if (skip)
+    return { action: "skip", reason: "FORGE_SKIP_CW_INSTALL is set" };
+  if (!bundle)
+    return { action: "skip", reason: "this Forge carries no CW" };
+  if (!installed) {
+    return cwOnPath ? { action: "skip", reason: "using the cw found on PATH" } : { action: "install", reason: "CW is not installed" };
+  }
+  if (!installed.version)
+    return { action: "skip", reason: "cannot read the installed CW version" };
+  const newer = compareVersions(bundle.version, installed.version);
+  const ownedByForge = marker !== null && marker.sha256 === installed.sha256;
+  if (ownedByForge) {
+    if (marker.ref === bundle.ref)
+      return { action: "skip", reason: `CW ${installed.version} is current` };
+    return newer >= 0 ? { action: "update", reason: `CW ${installed.version} \u2192 ${bundle.version}` } : { action: "skip", reason: `installed CW ${installed.version} is newer than ${bundle.version}` };
+  }
+  return newer > 0 ? { action: "update", reason: `CW ${installed.version} \u2192 ${bundle.version}` } : { action: "skip", reason: `CW ${installed.version} is current` };
+}
+function findOnPath(name, pathVar, excludeDir) {
+  for (const dir of (pathVar ?? "").split(delimiter2)) {
+    if (!dir || dir === excludeDir)
+      continue;
+    const candidate = join12(dir, name);
+    try {
+      if (!statSync3(candidate).isFile())
+        continue;
+      accessSync2(candidate, constants2.X_OK);
+      return candidate;
+    } catch {
+    }
+  }
+  return null;
+}
+function pathWithCw(cwHome, pathVar) {
+  const bin = join12(cwHome, "bin");
+  const rest = (pathVar ?? "").split(delimiter2).filter((dir) => dir && dir !== bin);
+  return [bin, ...rest].join(delimiter2);
+}
+function readMarker(cwHome) {
+  try {
+    return JSON.parse(readFileSync9(join12(cwHome, MARKER_FILE), "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function failureMessage2(output) {
+  const lines2 = output.replace(ANSI_RE3, "").split("\n").map((l) => l.trim()).filter(Boolean);
+  const errors = lines2.filter((l) => l.startsWith("[\u2717]")).map((l) => l.slice(3).trim());
+  return (errors.length > 0 ? errors : lines2.slice(-3)).join(" ") || "the CW installer failed";
+}
+async function ensureCw(options) {
+  const { cwHome, bundleDir } = options;
+  const env = options.env ?? process.env;
+  const run = options.run ?? runInstall;
+  const bin = join12(cwHome, "bin", "cw");
+  const bundle = readCwBundle(bundleDir);
+  const installed = existsSync11(bin) ? { version: readCwVersion(bin), sha256: sha256Of(bin) } : null;
+  const decision = decideCwInstall({
+    bundle,
+    installed,
+    marker: readMarker(cwHome),
+    cwOnPath: findOnPath("cw", env.PATH, join12(cwHome, "bin")) !== null,
+    skip: env.FORGE_SKIP_CW_INSTALL === "1"
+  });
+  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 });
+  if (code !== 0 || !existsSync11(bin))
+    return { action: "failed", message: failureMessage2(output) };
+  const marker = { version: bundle.version, ref: bundle.ref, sha256: sha256Of(bin) };
+  writeFileSync4(join12(cwHome, MARKER_FILE), JSON.stringify(marker, null, 2) + "\n");
+  return {
+    action: decision.action === "install" ? "installed" : "updated",
+    version: bundle.version,
+    message: decision.reason
+  };
+}
+var MARKER_FILE, INSTALL_TIMEOUT_MS2, ANSI_RE3, sha256Of, runInstall;
+var init_cw_install = __esm({
+  "../core/dist/cw-install.js"() {
+    "use strict";
+    MARKER_FILE = ".forge-cw.json";
+    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) => {
+      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 });
+        const code = err.code;
+        resolve5({ code: typeof code === "number" ? code : 1, output: output || err.message });
+      });
+    });
+  }
+});
+
+// ../core/dist/kioku.js
+import { spawn as spawn7 } from "node:child_process";
+import { existsSync as existsSync12 } from "node:fs";
+import { homedir as homedir5 } from "node:os";
+import { join as join13 } from "node:path";
+import { createInterface } from "node:readline";
+function resolveKiokuBin(pathVar = process.env.PATH, home = homedir5()) {
+  const fallback = join13(home, ".local", "bin", "kioku");
+  return findOnPath("kioku", pathVar) ?? (existsSync12(fallback) ? fallback : "kioku");
+}
+function rememberPrompt(text) {
+  return `Remember this with kioku: ${text.replace(/\s+/g, " ").trim()}`;
+}
+function parseJson(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+async function mapLimit(items, limit, fn) {
+  const out = new Array(items.length);
+  let next = 0;
+  const worker = async () => {
+    while (next < items.length) {
+      const i = next++;
+      out[i] = await fn(items[i]);
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(limit, items.length) }, worker));
+  return out;
+}
+var PAGE_TYPES, KiokuError, NOT_INSTALLED, START_TIMEOUT_MS, WRITE_TIMEOUT_MS, CACHE_MS2, ACTIVITY_SINCE, ACTIVITY_LIMIT, PARALLEL, MISSING, brainName, Kioku;
+var init_kioku = __esm({
+  "../core/dist/kioku.js"() {
+    "use strict";
+    init_task_review();
+    init_cw_doctor();
+    init_cw_install();
+    init_output();
+    PAGE_TYPES = {
+      memory: { kind: "memory" },
+      instinct: { kind: "memory", sub: "instinct" },
+      decision: { kind: "knowledge", sub: "decision" },
+      playbook: { kind: "knowledge", sub: "playbook" },
+      context: { kind: "knowledge", sub: "context" },
+      rule: { kind: "rule" }
+    };
+    KiokuError = class extends Error {
+      status;
+      constructor(message, status = 502) {
+        super(message);
+        this.status = status;
+      }
+    };
+    NOT_INSTALLED = "kioku is not installed on this machine";
+    START_TIMEOUT_MS = 2e4;
+    WRITE_TIMEOUT_MS = 6e4;
+    CACHE_MS2 = 5 * 6e4;
+    ACTIVITY_SINCE = "2w";
+    ACTIVITY_LIMIT = 40;
+    PARALLEL = 6;
+    MISSING = { installed: false, version: null, brains: [], projects: {}, activity: [] };
+    brainName = (b) => b.name ?? b.key;
+    Kioku = class {
+      run;
+      write;
+      startTimeoutMs;
+      projects;
+      now;
+      binPath;
+      viewer = null;
+      snapshot = null;
+      constructor(options = {}) {
+        this.binPath = options.bin;
+        this.run = options.run ?? createRunner();
+        this.write = options.write ?? createRunner(envWithoutHost(), WRITE_TIMEOUT_MS);
+        this.startTimeoutMs = options.startTimeoutMs ?? START_TIMEOUT_MS;
+        this.projects = options.projects ?? (() => ({}));
+        this.now = options.now ?? Date.now;
+      }
+      // resolved on first use, so a Forge that never opens Memory does not search PATH
+      get bin() {
+        return this.binPath ??= resolveKiokuBin();
+      }
+      async status(fresh = false) {
+        const previous = this.snapshot;
+        if (fresh || !previous || this.now() - previous.at > CACHE_MS2) {
+          const value = this.read();
+          this.snapshot = { at: this.now(), value };
+          value.catch(() => {
+            if (this.snapshot?.value === value)
+              this.snapshot = previous;
+          });
+        }
+        const pending = fresh || !previous ? this.snapshot.value : previous.value;
+        const [snapshot, viewer] = await Promise.all([pending, this.viewer?.catch(() => null) ?? null]);
+        return { ...snapshot, viewer: viewer?.address ?? null };
+      }
+      async json(args, cwd) {
+        const result2 = await this.run(this.bin, [...args, "--json"], cwd);
+        return result2.code === 0 ? parseJson(result2.stdout) : null;
+      }
+      async read() {
+        const [version, list] = await Promise.all([
+          this.run(this.bin, ["--version"], homedir5()),
+          this.json(["brain", "list"], homedir5())
+        ]);
+        if (version.code !== 0)
+          return MISSING;
+        const listed = list?.brains ?? [];
+        const entries = Object.entries(this.projects()).filter(([, p]) => existsSync12(p.path));
+        const readBrain = async (b) => {
+          if (!b.onDisk)
+            return { kinds: {}, namespaces: [], writes: [] };
+          const [ns, log] = await Promise.all([
+            this.json(["namespace", "list", "--brain", b.key], b.folder),
+            this.json(["brain", "log", "--since", ACTIVITY_SINCE, "--brain", b.key], b.folder)
+          ]);
+          const kinds = {};
+          const namespaces = ns?.brains?.find((x) => x.brain === brainName(b))?.namespaces ?? [];
+          for (const n of namespaces) {
+            for (const [kind, count] of Object.entries(n.pages))
+              kinds[kind] = (kinds[kind] ?? 0) + count;
+          }
+          return { kinds, namespaces: namespaces.map((n) => n.namespace), writes: log?.writes ?? [] };
+        };
+        const readChain = async (path) => (await this.json(["brain", "list"], path))?.chain ?? [];
+        const [perBrain, chains] = await Promise.all([
+          mapLimit(listed, PARALLEL / 2, readBrain),
+          mapLimit(entries, PARALLEL / 2, ([, p]) => readChain(p.path))
+        ]);
+        const activity = perBrain.flatMap((p) => p.writes).sort((x, y) => y.date.localeCompare(x.date));
+        const brains = listed.map((b, i) => {
+          const { kinds, namespaces } = perBrain[i];
+          const name = brainName(b);
+          return {
+            ...b,
+            pages: Object.values(kinds).reduce((sum, n) => sum + n, 0),
+            kinds,
+            namespaces,
+            touched: activity.find((w) => w.brain === name)?.date ?? null
+          };
+        });
+        const projects = Object.fromEntries(entries.map(([name], i) => [name, chains[i].map(({ name: name2, tier }) => ({ name: name2, tier }))]));
+        return {
+          installed: true,
+          version: parseJson(version.stdout)?.version ?? null,
+          brains,
+          projects,
+          activity: activity.slice(0, ACTIVITY_LIMIT).map(({ verb, title, path, date, author, brain }) => ({ verb, title, path, date, author, brain }))
+        };
+      }
+      // writes through kioku, which validates, commits and pushes a shared brain; Forge never writes a brain's files
+      async save(input) {
+        const type = PAGE_TYPES[input.type];
+        if (!type)
+          throw new KiokuError(`unknown page type ${input.type}`, 400);
+        const brains = this.snapshot ? (await this.snapshot.value).brains : (await this.json(["brain", "list"], homedir5()))?.brains ?? [];
+        const brain = brains.find((b) => b.key === input.brain);
+        if (!brain?.onDisk)
+          throw new KiokuError(`no brain ${input.brain} on this machine`, 404);
+        const args = [
+          "page",
+          "save",
+          "--brain",
+          brain.key,
+          "--kind",
+          type.kind,
+          ...type.sub ? ["--sub", type.sub] : [],
+          "--title",
+          input.title,
+          "--summary",
+          input.summary,
+          "--source",
+          "Forge",
+          ...input.namespace ? ["--namespace", input.namespace] : [],
+          ...input.create ? ["--create"] : [],
+          "--json"
+        ];
+        const result2 = await this.write(this.bin, args, brain.folder, input.body);
+        if (result2.code === 127)
+          throw new KiokuError(NOT_INSTALLED, 404);
+        const out = parseJson(result2.stdout);
+        if (out?.status === "done" && out.path) {
+          this.snapshot = null;
+          return { status: "done", brain: brainName(brain), path: out.path, publication: out.publication ?? null };
+        }
+        if (out?.status === "similar")
+          return { status: "similar", similar: (out.similar ?? []).map(({ brain: brain2, path, title, summary }) => ({ brain: brain2, path, title, summary })) };
+        if (out?.status === "namespace")
+          return { status: "namespace", namespaces: (out.namespaces ?? []).map(({ namespace, summary }) => ({ namespace, summary })) };
+        throw new KiokuError(out?.error?.message ?? (tailOutput(result2.stderr, 1) || "kioku could not save the page"), 400);
+      }
+      // one viewer at a time; a second call reuses the running one
+      async openViewer() {
+        this.viewer ??= this.startViewer();
+        return (await this.viewer).address;
+      }
+      startViewer() {
+        const started = new Promise((resolve5, reject) => {
+          const child = spawn7(this.bin, ["web", "--json", "--no-open"], { cwd: homedir5(), stdio: ["ignore", "pipe", "pipe"] });
+          const lines2 = createInterface({ input: child.stdout });
+          let stderr = "";
+          let settled = false;
+          const finish = () => {
+            settled = true;
+            clearTimeout(timer);
+            lines2.close();
+            child.stdout?.resume();
+          };
+          const fail = (err) => {
+            if (settled)
+              return;
+            finish();
+            child.kill();
+            reject(err);
+          };
+          const timer = setTimeout(() => fail(new KiokuError("kioku web did not start in time")), this.startTimeoutMs);
+          child.stderr?.on("data", (chunk) => {
+            stderr = (stderr + chunk.toString()).slice(-4096);
+          });
+          lines2.on("line", (line) => {
+            const event = parseJson(line);
+            if (settled || event?.event !== "listening" || !event.address?.startsWith("http://127.0.0.1:"))
+              return;
+            finish();
+            resolve5({ child, address: event.address });
+          });
+          child.on("error", (err) => {
+            const missing = err.code === "ENOENT";
+            fail(new KiokuError(missing ? NOT_INSTALLED : err.message, missing ? 404 : 502));
+          });
+          child.on("close", (code) => {
+            if (this.viewer === started)
+              this.viewer = null;
+            fail(new KiokuError(tailOutput(stderr, 1) || `kioku web exited with code ${code}`));
+          });
+        });
+        started.catch(() => {
+          if (this.viewer === started)
+            this.viewer = null;
+        });
+        return started;
+      }
+      stopViewer() {
+        void this.viewer?.then((v) => v.child.kill(), () => {
+        });
+        this.viewer = null;
+      }
+      dispose() {
+        this.stopViewer();
+      }
+    };
+  }
+});
+
+// ../core/dist/kioku-routes.js
 import { Hono as Hono4 } from "hono";
+function kiokuRoutes(kioku = new Kioku(), options = {}) {
+  const app = new Hono4();
+  app.onError((err, c) => {
+    if (err instanceof KiokuError)
+      return c.json({ error: err.message }, err.status);
+    throw err;
+  });
+  app.get("/status", async (c) => c.json(await kioku.status(c.req.query("fresh") === "1")));
+  app.post("/pages", async (c) => {
+    const input = await c.req.json().catch(() => ({}));
+    const brain = input.brain?.trim();
+    const title = input.title?.trim();
+    const summary = input.summary?.trim();
+    if (!brain || !input.type || !title || !summary || !input.body?.trim())
+      return c.json({ error: "brain, type, title, summary and body are required" }, 400);
+    const result2 = await kioku.save({ brain, type: input.type, title, summary, body: input.body, namespace: input.namespace?.trim() || void 0, create: input.create === true });
+    return c.json(result2, result2.status === "done" ? 201 : 200);
+  });
+  app.post("/remember", async (c) => {
+    const { project, sessionDir, text } = await c.req.json().catch(() => ({}));
+    const line = text?.trim();
+    if (!project || !sessionDir || !line)
+      return c.json({ error: "project, sessionDir and text are required" }, 400);
+    if (line.length > REMEMBER_MAX)
+      return c.json({ error: `keep it under ${REMEMBER_MAX} characters` }, 400);
+    if (options.canRemember && !options.canRemember(project, sessionDir))
+      return c.json({ error: "only Claude Code sessions have kioku's skill" }, 400);
+    if (!options.type?.(project, sessionDir, rememberPrompt(line)))
+      return c.json({ error: "the session has no live terminal" }, 409);
+    return c.json({ ok: true });
+  });
+  app.post("/viewer", async (c) => c.json({ address: await kioku.openViewer() }));
+  app.delete("/viewer", (c) => {
+    kioku.stopViewer();
+    return c.json({ ok: true });
+  });
+  return app;
+}
+var REMEMBER_MAX;
+var init_kioku_routes = __esm({
+  "../core/dist/kioku-routes.js"() {
+    "use strict";
+    init_kioku();
+    REMEMBER_MAX = 500;
+  }
+});
+
+// ../core/dist/server.js
+import { Hono as Hono5 } from "hono";
 import { cors } from "hono/cors";
-import { join as join12, basename as basename3, resolve as resolve4 } from "node:path";
-import { readdirSync as readdirSync6, existsSync as existsSync11 } from "node:fs";
+import { join as join14, basename as basename3, resolve as resolve4 } from "node:path";
+import { readdirSync as readdirSync6, existsSync as existsSync13 } from "node:fs";
 function createForgeServer(options) {
   const { dataDir, db: externalDb, authToken, localOnly = true } = options;
-  const dbPath = join12(dataDir, "forge.db");
-  const modulesDir = join12(dataDir, "modules");
+  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 Hono4();
+  const app = new Hono5();
   app.use("*", localOnly ? localOriginGuard() : cors());
   if (authToken) {
     app.use("/api/*", bearerAuth(authToken));
@@ -3973,9 +4433,15 @@ function createForgeServer(options) {
     }
   });
   const ptyManager = new PTYManager(states);
-  const generalSessions = new GeneralSessions(join12(dataDir, "general-sessions.json"));
+  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();
@@ -4131,21 +4597,21 @@ data: ${JSON.stringify(data)}
     if (!dir.startsWith(home)) {
       return c.json({ error: "Access denied: path must be within home directory" }, 403);
     }
-    if (!existsSync11(dir)) {
+    if (!existsSync13(dir)) {
       return c.json({ error: "Directory not found" }, 404);
     }
     try {
       const entries = readdirSync6(dir, { withFileTypes: true });
       const dirs = entries.filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => ({
         name: e.name,
-        path: join12(dir, e.name),
-        hasPackageJson: existsSync11(join12(dir, e.name, "package.json")),
-        hasGit: existsSync11(join12(dir, e.name, ".git"))
+        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));
       return c.json({
         current: dir,
         name: basename3(dir),
-        parent: join12(dir, ".."),
+        parent: join14(dir, ".."),
         directories: dirs
       });
     } catch {
@@ -4163,6 +4629,7 @@ data: ${JSON.stringify(data)}
       ptyManager.dispose();
       states.dispose();
       loginManager.dispose();
+      kioku.dispose();
       db.close();
     }
   };
@@ -4186,6 +4653,8 @@ var init_server = __esm({
     init_login_manager();
     init_general_sessions();
     init_liveframe_routes();
+    init_kioku_routes();
+    init_kioku();
   }
 });
 
@@ -4308,8 +4777,8 @@ async function createDatabase(opts) {
     await db.migrate();
     return db;
   }
-  const { join: join16 } = await import("node:path");
-  return new ForgeDB(join16(opts.dataDir, "forge.db"));
+  const { join: join17 } = await import("node:path");
+  return new ForgeDB(join17(opts.dataDir, "forge.db"));
 }
 var init_db_factory = __esm({
   "../core/dist/db-factory.js"() {
@@ -4319,22 +4788,22 @@ var init_db_factory = __esm({
 });
 
 // ../core/dist/init.js
-import { existsSync as existsSync12, mkdirSync as mkdirSync5, writeFileSync as writeFileSync4 } from "node:fs";
-import { join as join13 } from "node:path";
-import { homedir as homedir5 } from "node:os";
+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";
 function getForgeDir() {
-  return join13(homedir5(), ".forge");
+  return join15(homedir6(), ".forge");
 }
 function ensureForgeDir() {
   const forgeDir = getForgeDir();
-  if (existsSync12(forgeDir)) {
+  if (existsSync14(forgeDir)) {
     return { forgeDir, created: false };
   }
   mkdirSync5(forgeDir, { recursive: true });
   for (const d of FORGE_SUBDIRS) {
-    mkdirSync5(join13(forgeDir, d), { recursive: true });
+    mkdirSync5(join15(forgeDir, d), { recursive: true });
   }
-  writeFileSync4(join13(forgeDir, "config.json"), JSON.stringify({
+  writeFileSync5(join15(forgeDir, "config.json"), JSON.stringify({
     port: 3e3,
     theme: "dark",
     openBrowser: true,
@@ -4350,138 +4819,6 @@ var init_init = __esm({
   }
 });
 
-// ../core/dist/cw-install.js
-import { execFile as execFile5 } from "node:child_process";
-import { createHash as createHash2 } from "node:crypto";
-import { accessSync as accessSync2, constants as constants2, existsSync as existsSync13, readFileSync as readFileSync9, statSync as statSync3, writeFileSync as writeFileSync5 } from "node:fs";
-import { delimiter as delimiter2, join as join14 } from "node:path";
-function readCwVersion(file) {
-  try {
-    const match = /^CW_VERSION="([^"]+)"/m.exec(readFileSync9(file, "utf-8"));
-    return match ? match[1] : null;
-  } catch {
-    return null;
-  }
-}
-function compareVersions(a, b) {
-  const pa = a.split(".").map((n) => parseInt(n, 10) || 0);
-  const pb = b.split(".").map((n) => parseInt(n, 10) || 0);
-  for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
-    const diff = (pa[i] ?? 0) - (pb[i] ?? 0);
-    if (diff !== 0)
-      return diff;
-  }
-  return 0;
-}
-function readCwBundle(dir) {
-  try {
-    const { ref } = JSON.parse(readFileSync9(join14(dir, ".bundle.json"), "utf-8"));
-    const version = readCwVersion(join14(dir, "cw"));
-    if (!ref || !version || !existsSync13(join14(dir, "install.sh")))
-      return null;
-    return { dir, version, ref };
-  } catch {
-    return null;
-  }
-}
-function decideCwInstall({ bundle, installed, marker, cwOnPath, skip }) {
-  if (skip)
-    return { action: "skip", reason: "FORGE_SKIP_CW_INSTALL is set" };
-  if (!bundle)
-    return { action: "skip", reason: "this Forge carries no CW" };
-  if (!installed) {
-    return cwOnPath ? { action: "skip", reason: "using the cw found on PATH" } : { action: "install", reason: "CW is not installed" };
-  }
-  if (!installed.version)
-    return { action: "skip", reason: "cannot read the installed CW version" };
-  const newer = compareVersions(bundle.version, installed.version);
-  const ownedByForge = marker !== null && marker.sha256 === installed.sha256;
-  if (ownedByForge) {
-    if (marker.ref === bundle.ref)
-      return { action: "skip", reason: `CW ${installed.version} is current` };
-    return newer >= 0 ? { action: "update", reason: `CW ${installed.version} \u2192 ${bundle.version}` } : { action: "skip", reason: `installed CW ${installed.version} is newer than ${bundle.version}` };
-  }
-  return newer > 0 ? { action: "update", reason: `CW ${installed.version} \u2192 ${bundle.version}` } : { action: "skip", reason: `CW ${installed.version} is current` };
-}
-function findOnPath(name, pathVar, excludeDir) {
-  for (const dir of (pathVar ?? "").split(delimiter2)) {
-    if (!dir || dir === excludeDir)
-      continue;
-    const candidate = join14(dir, name);
-    try {
-      if (!statSync3(candidate).isFile())
-        continue;
-      accessSync2(candidate, constants2.X_OK);
-      return candidate;
-    } catch {
-    }
-  }
-  return null;
-}
-function pathWithCw(cwHome, pathVar) {
-  const bin = join14(cwHome, "bin");
-  const rest = (pathVar ?? "").split(delimiter2).filter((dir) => dir && dir !== bin);
-  return [bin, ...rest].join(delimiter2);
-}
-function readMarker(cwHome) {
-  try {
-    return JSON.parse(readFileSync9(join14(cwHome, MARKER_FILE), "utf-8"));
-  } catch {
-    return null;
-  }
-}
-function failureMessage2(output) {
-  const lines2 = output.replace(ANSI_RE3, "").split("\n").map((l) => l.trim()).filter(Boolean);
-  const errors = lines2.filter((l) => l.startsWith("[\u2717]")).map((l) => l.slice(3).trim());
-  return (errors.length > 0 ? errors : lines2.slice(-3)).join(" ") || "the CW installer failed";
-}
-async function ensureCw(options) {
-  const { cwHome, bundleDir } = options;
-  const env = options.env ?? process.env;
-  const run = options.run ?? runInstall;
-  const bin = join14(cwHome, "bin", "cw");
-  const bundle = readCwBundle(bundleDir);
-  const installed = existsSync13(bin) ? { version: readCwVersion(bin), sha256: sha256Of(bin) } : null;
-  const decision = decideCwInstall({
-    bundle,
-    installed,
-    marker: readMarker(cwHome),
-    cwOnPath: findOnPath("cw", env.PATH, join14(cwHome, "bin")) !== null,
-    skip: env.FORGE_SKIP_CW_INSTALL === "1"
-  });
-  if (decision.action === "skip" || !bundle)
-    return { action: "skipped", message: decision.reason };
-  const { code, output } = await run(join14(bundle.dir, "install.sh"), ["--no-shell"], { ...env, CW_HOME: cwHome });
-  if (code !== 0 || !existsSync13(bin))
-    return { action: "failed", message: failureMessage2(output) };
-  const marker = { version: bundle.version, ref: bundle.ref, sha256: sha256Of(bin) };
-  writeFileSync5(join14(cwHome, MARKER_FILE), JSON.stringify(marker, null, 2) + "\n");
-  return {
-    action: decision.action === "install" ? "installed" : "updated",
-    version: bundle.version,
-    message: decision.reason
-  };
-}
-var MARKER_FILE, INSTALL_TIMEOUT_MS2, ANSI_RE3, sha256Of, runInstall;
-var init_cw_install = __esm({
-  "../core/dist/cw-install.js"() {
-    "use strict";
-    MARKER_FILE = ".forge-cw.json";
-    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) => {
-      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 });
-        const code = err.code;
-        resolve5({ code: typeof code === "number" ? code : 1, output: output || err.message });
-      });
-    });
-  }
-});
-
 // ../core/dist/port-in-use.js
 function waitForListening(server) {
   if (server.listening)
@@ -4537,6 +4874,8 @@ __export(dist_exports, {
   ForgeDB: () => ForgeDB,
   HARNESS_CAPABILITIES: () => HARNESS_CAPABILITIES,
   HARNESS_NAME_RE: () => HARNESS_NAME_RE,
+  Kioku: () => Kioku,
+  KiokuError: () => KiokuError,
   Liveframe: () => Liveframe,
   LiveframeError: () => LiveframeError,
   MODEL_NAME_RE: () => MODEL_NAME_RE,
@@ -4551,11 +4890,14 @@ __export(dist_exports, {
   ensureCw: () => ensureCw,
   ensureForgeDir: () => ensureForgeDir,
   getForgeDir: () => getForgeDir,
+  kiokuRoutes: () => kiokuRoutes,
   liveframeRoutes: () => liveframeRoutes,
   pathWithCw: () => pathWithCw,
   portInUseMessage: () => portInUseMessage,
   probePort: () => probePort,
   quietSqliteWarning: () => quietSqliteWarning,
+  rememberPrompt: () => rememberPrompt,
+  resolveKiokuBin: () => resolveKiokuBin,
   resolveListenOptions: () => resolveListenOptions,
   skillRoutes: () => skillRoutes,
   supports: () => supports,
@@ -4584,14 +4926,16 @@ var init_dist = __esm({
     init_pty_routes();
     init_liveframe_routes();
     init_liveframe();
+    init_kioku_routes();
+    init_kioku();
     init_port_in_use();
   }
 });
 
 // src/index.ts
-import { existsSync as existsSync14, readFileSync as readFileSync10 } from "node:fs";
-import { homedir as homedir6 } from "node:os";
-import { join as join15 } from "node:path";
+import { existsSync as existsSync15, readFileSync as readFileSync10 } from "node:fs";
+import { homedir as homedir7 } from "node:os";
+import { join as join16 } from "node:path";
 function parseArgs(argv) {
   const out = { open: true };
   for (let i = 0; i < argv.length; i++) {
@@ -4602,11 +4946,11 @@ function parseArgs(argv) {
   }
   return out;
 }
-var packageRoot = join15(import.meta.dirname, "..");
-var isCheckout = existsSync14(join15(packageRoot, "src"));
-var consoleDist = isCheckout ? join15(packageRoot, "../console/dist") : join15(packageRoot, "console");
-var forgeVersion = JSON.parse(readFileSync10(join15(packageRoot, "package.json"), "utf-8")).version;
-var bundledModulesDir = isCheckout ? join15(packageRoot, "../../modules") : join15(packageRoot, "modules");
+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");
 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));
   quietSqliteWarning2();
@@ -4615,8 +4959,8 @@ async function main() {
   if (created) {
     console.log("First run \u2014 initialized Forge.");
   }
-  const cwHome = join15(process.env.HOME ?? homedir6(), ".cw");
-  const cw = isCheckout ? { action: "skipped", message: "a checkout does not install CW" } : await ensureCw2({ cwHome, bundleDir: join15(packageRoot, "cw") });
+  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") });
   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}`);
@@ -4641,9 +4985,9 @@ async function main() {
     version: forgeVersion
   });
   const { serveStatic } = await import("@hono/node-server/serve-static");
-  if (existsSync14(join15(consoleDist, "index.html"))) {
+  if (existsSync15(join16(consoleDist, "index.html"))) {
     server.app.use("/*", serveStatic({ root: consoleDist }));
-    const indexHtml = readFileSync10(join15(consoleDist, "index.html"), "utf-8");
+    const indexHtml = readFileSync10(join16(consoleDist, "index.html"), "utf-8");
     server.app.get("*", (c) => c.html(indexHtml));
   }
   const { serve } = await import("@hono/node-server");