forge-cw 0.1.8 → 0.1.10

package/console/index.html

@@ -4,7 +4,7 @@
   <meta charset="UTF-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
   <title>Forge Console</title>
-  <script type="module" crossorigin src="/assets/index-BpkdtYRb.js"></script>
+  <script type="module" crossorigin src="/assets/index-5ifgSOpU.js"></script>
   <link rel="stylesheet" crossorigin href="/assets/index-N7b3C-h8.css">
 </head>
 <body>

package/dist/index.js

@@ -656,7 +656,7 @@ var init_cw_reader = __esm({
         if (!match)
           return { frontmatter: {}, body: content };
         const rawBlock = match[1];
-        const body = match[2];
+        const body2 = match[2];
         const frontmatter = {};
         let inMetadata = false;
         const metadataObj = {};
@@ -680,7 +680,7 @@ var init_cw_reader = __esm({
         }
         if (Object.keys(metadataObj).length > 0)
           frontmatter["metadata"] = metadataObj;
-        return { frontmatter, body };
+        return { frontmatter, body: body2 };
       }
       // directory whose skills/ holds a scope's skills; an unregistered project ref is used as a path
       getSkillConfigDir(scope, scopeRef) {
@@ -742,7 +742,7 @@ var init_cw_reader = __esm({
           return null;
         try {
           const content = readFileSync2(skillMd, "utf-8");
-          const { frontmatter, body } = this.parseFrontmatter(content);
+          const { frontmatter, body: body2 } = this.parseFrontmatter(content);
           const references = [];
           const refsDir = join2(dir, "references");
           if (existsSync2(refsDir)) {
@@ -755,7 +755,7 @@ var init_cw_reader = __esm({
               }
             }
           }
-          return { name: String(frontmatter["name"] ?? name), scope, scopeRef, frontmatter, body, references };
+          return { name: String(frontmatter["name"] ?? name), scope, scopeRef, frontmatter, body: body2, references };
         } catch {
           return null;
         }
@@ -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) {
@@ -1298,10 +1311,10 @@ async function probeClaudeUsage(configDir, deps = {}) {
     });
     if (response.status === 401 || response.status === 403)
       return { state: "expired", windows: [], detail: "Claude rejected the stored token" };
-    const body = await response.text();
+    const body2 = await response.text();
     if (!response.ok)
       return { state: "error", windows: [], detail: `Claude answered ${response.status}` };
-    return { state: "ok", windows: mapClaudeUsage(JSON.parse(body)), detail: null };
+    return { state: "ok", windows: mapClaudeUsage(JSON.parse(body2)), detail: null };
   } catch (err) {
     return { state: "error", windows: [], detail: err instanceof Error ? err.message : String(err) };
   }
@@ -1526,9 +1539,9 @@ var init_login_manager = __esm({
       cwBin;
       spawn;
       entries = /* @__PURE__ */ new Map();
-      constructor(cwBin, spawn8 = spawnInPty) {
+      constructor(cwBin, spawn9 = spawnInPty) {
         this.cwBin = cwBin;
-        this.spawn = spawn8;
+        this.spawn = spawn9;
       }
       start(account, harness) {
         const key = `${account}::${harness}`;
@@ -1812,14 +1825,14 @@ function cwRoutes(reader, options = {}) {
     return c.json(reader.getAccounts());
   });
   app.post("/accounts", async (c) => {
-    const body = await c.req.json();
-    const harness = body.harness || void 0;
-    const provider = body.provider || void 0;
-    const model = body.model || void 0;
-    if (!body.name || !body.name.trim()) {
+    const body2 = await c.req.json();
+    const harness = body2.harness || void 0;
+    const provider = body2.provider || void 0;
+    const model = body2.model || void 0;
+    if (!body2.name || !body2.name.trim()) {
       return c.json({ ok: false, error: "Account name is required" }, 400);
     }
-    const trimmed = body.name.trim();
+    const trimmed = body2.name.trim();
     if (!ACCOUNT_NAME_RE.test(trimmed)) {
       return c.json({ ok: false, error: "Name must start with a letter or number and contain only letters, numbers, hyphens, and underscores (max 64 chars)" }, 400);
     }
@@ -2883,11 +2896,11 @@ function skillRoutes(reader, options = {}) {
   });
   app.get("/marketplaces", (c) => c.json(listMarketplaces(reader)));
   app.post("/marketplaces", async (c) => {
-    const body = await c.req.json().catch(() => ({}));
-    const source = body.source?.trim() ?? "";
+    const body2 = await c.req.json().catch(() => ({}));
+    const source = body2.source?.trim() ?? "";
     if (!source || source.startsWith("-"))
       return c.json({ error: "A GitHub repo, URL or path is required" }, 400);
-    const account = knownAccount(body.account);
+    const account = knownAccount(body2.account);
     if (!account)
       return c.json({ error: "Unknown account" }, 404);
     const failed = await runClaude("account", account, [["plugin", "marketplace", "add", source]], `Failed to add ${source}`);
@@ -2896,11 +2909,11 @@ function skillRoutes(reader, options = {}) {
     return c.json({ ok: true });
   });
   app.post("/plugins/install", async (c) => {
-    const body = await c.req.json().catch(() => ({}));
-    const id = body.id ?? "";
+    const body2 = await c.req.json().catch(() => ({}));
+    const id = body2.id ?? "";
     if (!PLUGIN_ID_RE.test(id))
       return c.json({ error: "Invalid plugin id" }, 400);
-    const account = knownAccount(body.account);
+    const account = knownAccount(body2.account);
     if (!account)
       return c.json({ error: "Unknown account" }, 404);
     const { name, marketplace } = splitPluginId(id);
@@ -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);
@@ -3237,7 +3259,7 @@ function createJevClassifier({ apiKey, model = "jev-latest", timeoutMs = 3e3, fe
     async classify(input) {
       if (input.exitCode !== null)
         return { state: "exited", confidence: 1, source: "jev" };
-      const body = {
+      const body2 = {
         model,
         state: { harness: input.harness, seconds_since_last_output: Math.round(input.quietMs / 1e3), screen: jevScreen(input.screen ?? input.text) },
         questions: {
@@ -3251,7 +3273,7 @@ function createJevClassifier({ apiKey, model = "jev-latest", timeoutMs = 3e3, fe
       const res = await fetch2(JEV_URL, {
         method: "POST",
         headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },
-        body: JSON.stringify(body),
+        body: JSON.stringify(body2),
         signal: AbortSignal.timeout(timeoutMs)
       });
       if (!res.ok)
@@ -4070,10 +4092,38 @@ 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";
+import * as pty3 from "node-pty";
+function assertRepo(repo, what) {
+  if (!REPO.test(repo))
+    throw new KiokuError(`${what} is named as owner/repo, not "${repo}"`, 400);
+}
 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 createTerminalRunner(env, timeoutMs) {
+  return (bin, args, cwd) => new Promise((resolve5) => {
+    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" });
+    }
+    let output = "";
+    const timer = setTimeout(() => proc.kill(), timeoutMs);
+    proc.onData((data) => {
+      output = (output + data).slice(-64 * 1024);
+    });
+    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 });
+    });
+  });
+}
 function parseJson(text) {
   try {
     return JSON.parse(text);
@@ -4093,13 +4143,22 @@ async function mapLimit(items, limit, fn) {
   await Promise.all(Array.from({ length: Math.min(limit, items.length) }, worker));
   return out;
 }
-var KiokuError, NOT_INSTALLED, START_TIMEOUT_MS, CACHE_MS2, ACTIVITY_SINCE, ACTIVITY_LIMIT, PARALLEL, MISSING, brainName, Kioku;
+var PAGE_TYPES, KiokuError, NOT_INSTALLED, START_TIMEOUT_MS, WRITE_TIMEOUT_MS, PUBLISH_TIMEOUT_MS, CACHE_MS2, ACTIVITY_SINCE, ACTIVITY_LIMIT, PARALLEL, TIERS, REPO, AREA, LANGUAGE, 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) {
@@ -4109,14 +4168,22 @@ var init_kioku = __esm({
     };
     NOT_INSTALLED = "kioku is not installed on this machine";
     START_TIMEOUT_MS = 2e4;
+    WRITE_TIMEOUT_MS = 6e4;
+    PUBLISH_TIMEOUT_MS = 3 * 6e4;
     CACHE_MS2 = 5 * 6e4;
     ACTIVITY_SINCE = "2w";
     ACTIVITY_LIMIT = 40;
     PARALLEL = 6;
+    TIERS = ["personal", "project", "team"];
+    REPO = /^[\w.-]+\/[\w.-]+(\/[\w.-]+)?$/;
+    AREA = /^[A-Za-z0-9][\w.-]*(\/[A-Za-z0-9][\w.-]*)*$/;
+    LANGUAGE = /^[A-Za-z]{2,3}(-[A-Za-z0-9]+)*$/;
     MISSING = { installed: false, version: null, brains: [], projects: {}, activity: [] };
     brainName = (b) => b.name ?? b.key;
     Kioku = class {
       run;
+      write;
+      terminal;
       startTimeoutMs;
       projects;
       now;
@@ -4126,6 +4193,8 @@ var init_kioku = __esm({
       constructor(options = {}) {
         this.binPath = options.bin;
         this.run = options.run ?? createRunner();
+        this.write = options.write ?? createRunner(envWithoutHost(), WRITE_TIMEOUT_MS);
+        this.terminal = options.terminal;
         this.startTimeoutMs = options.startTimeoutMs ?? START_TIMEOUT_MS;
         this.projects = options.projects ?? (() => ({}));
         this.now = options.now ?? Date.now;
@@ -4163,17 +4232,18 @@ var init_kioku = __esm({
         const entries = Object.entries(this.projects()).filter(([, p]) => existsSync12(p.path));
         const readBrain = async (b) => {
           if (!b.onDisk)
-            return { kinds: {}, writes: [] };
+            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 = {};
-          for (const n of ns?.brains?.find((x) => x.brain === brainName(b))?.namespaces ?? []) {
+          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, writes: log?.writes ?? [] };
+          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([
@@ -4182,12 +4252,13 @@ var init_kioku = __esm({
         ]);
         const activity = perBrain.flatMap((p) => p.writes).sort((x, y) => y.date.localeCompare(x.date));
         const brains = listed.map((b, i) => {
-          const { kinds } = perBrain[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
           };
         });
@@ -4200,6 +4271,133 @@ var init_kioku = __esm({
           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 brain = await this.findBrain(input.brain);
+        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 { out, fail } = await this.invoke(args, brain.folder, this.write, input.body);
+        if (out?.status === "done" && out.path) {
+          this.expire();
+          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 fail("kioku could not save the page");
+      }
+      // the cached reading when there is one, else only the list of brains
+      async listBrains() {
+        return this.snapshot ? (await this.snapshot.value).brains : (await this.json(["brain", "list"], homedir5()))?.brains ?? [];
+      }
+      async findBrain(key) {
+        const brain = (await this.listBrains()).find((b) => b.key === key);
+        if (!brain?.onDisk)
+          throw new KiokuError(`no brain ${key} on this machine`, 404);
+        return brain;
+      }
+      // the next status reads again, while the old reading still answers a poll that is not fresh
+      expire() {
+        if (this.snapshot)
+          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);
+        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);
+        if (!ok || !out)
+          throw fail(`kioku ${args.slice(0, 2).join(" ")} failed`);
+        this.expire();
+        return out;
+      }
+      // makes a brain on this machine only; kioku never makes a repository here
+      async createBrain(input) {
+        assertRepo(input.repo, "the brain");
+        if (!TIERS.includes(input.tier))
+          throw new KiokuError(`the tier is one of ${TIERS.join(", ")}`, 400);
+        if (input.team)
+          assertRepo(input.team, "the team brain");
+        if (input.language && !LANGUAGE.test(input.language))
+          throw new KiokuError("the language is a tag such as en or es", 400);
+        const args = [
+          "brain",
+          "create",
+          input.repo,
+          "--tier",
+          input.tier,
+          ...input.team && input.tier === "project" ? ["--team", input.team] : [],
+          ...input.language ? ["--language", input.language] : []
+        ];
+        const { brain, name, path } = await this.change(args, homedir5());
+        return { brain, name, path };
+      }
+      async addArea(key, area, summary) {
+        if (!AREA.test(area))
+          throw new KiokuError("an area is letters, digits, dots, dashes and underscores, with / between parts", 400);
+        if (!summary)
+          throw new KiokuError("say what the area is for", 400);
+        const brain = await this.findBrain(key);
+        const out = await this.change(["namespace", "add", area, `--summary=${summary}`, "--brain", brain.key], brain.folder);
+        return { brain: out.brain, namespace: out.namespace };
+      }
+      // writes the project's kioku.yaml; a brain the machine does not know is made first, since kioku links only known brains without a terminal
+      async linkProject(input) {
+        if (!input.brain && !input.team)
+          throw new KiokuError("name a project brain, a team brain, or both", 400);
+        const path = this.projects()[input.project]?.path;
+        if (!path || !existsSync12(path))
+          throw new KiokuError(`no CW project ${input.project} on this machine`, 404);
+        if (input.brain)
+          assertRepo(input.brain, "the project brain");
+        if (input.team)
+          assertRepo(input.team, "the team brain");
+        const known = await this.listBrains();
+        const isKnown = (repo) => known.some((b) => b.key === repo || b.key.endsWith(`/${repo}`));
+        const created = [];
+        if (input.team && !isKnown(input.team))
+          created.push((await this.createBrain({ repo: input.team, tier: "team" })).brain);
+        if (input.brain && !isKnown(input.brain))
+          created.push((await this.createBrain({ repo: input.brain, tier: "project", team: input.team })).brain);
+        const args = ["init", ...input.brain ? [input.brain] : [], ...input.team ? ["--team", input.team] : []];
+        const { file } = await this.change(args, path);
+        return { file, created };
+      }
+      // the only verb that reaches a git host: without `to`, kioku makes a private GitHub repository with gh
+      async publish(key, to) {
+        if (to?.startsWith("-"))
+          throw new KiokuError("the address cannot start with -", 400);
+        const brain = await this.findBrain(key);
+        if (brain.remote)
+          throw new KiokuError(`${brainName(brain)} already has a repository: ${brain.remote}`, 400);
+        const out = await this.change(["brain", "publish", brain.key, ...to ? ["--to", to] : []], brain.folder, this.terminal ??= createTerminalRunner(envWithoutHost(), PUBLISH_TIMEOUT_MS));
+        return { brain: out.brain, status: out.status, remote: out.remote ?? null };
+      }
       // one viewer at a time; a second call reuses the running one
       async openViewer() {
         this.viewer ??= this.startViewer();
@@ -4239,7 +4437,7 @@ var init_kioku = __esm({
             const missing = err.code === "ENOENT";
             fail(new KiokuError(missing ? NOT_INSTALLED : err.message, missing ? 404 : 502));
           });
-          child.on("exit", (code) => {
+          child.on("close", (code) => {
             if (this.viewer === started)
               this.viewer = null;
             fail(new KiokuError(tailOutput(stderr, 1) || `kioku web exited with code ${code}`));
@@ -4265,7 +4463,7 @@ var init_kioku = __esm({
 
 // ../core/dist/kioku-routes.js
 import { Hono as Hono4 } from "hono";
-function kiokuRoutes(kioku = new Kioku()) {
+function kiokuRoutes(kioku = new Kioku(), options = {}) {
   const app = new Hono4();
   app.onError((err, c) => {
     if (err instanceof KiokuError)
@@ -4273,6 +4471,47 @@ function kiokuRoutes(kioku = new Kioku()) {
     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("/brains", async (c) => {
+    const { repo, tier, team, language } = await body(c);
+    return c.json(await kioku.createBrain({ repo: trim(repo) ?? "", tier: tier ?? "", team: trim(team), language: trim(language) }), 201);
+  });
+  app.post("/areas", async (c) => {
+    const { brain, area, summary } = await body(c);
+    return c.json(await kioku.addArea(brain ?? "", trim(area) ?? "", trim(summary) ?? ""), 201);
+  });
+  app.post("/link", async (c) => {
+    const { project, brain, team } = await body(c);
+    return c.json(await kioku.linkProject({ project: project ?? "", brain: trim(brain), team: trim(team) }));
+  });
+  app.post("/publish", async (c) => {
+    const { brain, to, understood } = await body(c);
+    if (understood !== true)
+      return c.json({ error: "publishing needs the warning accepted" }, 400);
+    return c.json(await kioku.publish(brain ?? "", trim(to)));
+  });
+  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();
@@ -4280,10 +4519,14 @@ function kiokuRoutes(kioku = new Kioku()) {
   });
   return app;
 }
+var trim, REMEMBER_MAX, body;
 var init_kioku_routes = __esm({
   "../core/dist/kioku-routes.js"() {
     "use strict";
     init_kioku();
+    trim = (value) => value?.trim() || void 0;
+    REMEMBER_MAX = 500;
+    body = (c) => c.req.json().catch(() => ({}));
   }
 });
 
@@ -4332,7 +4575,11 @@ function createForgeServer(options) {
   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));
+  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();
@@ -4461,8 +4708,8 @@ data: ${JSON.stringify(data)}
   });
   app.put("/api/modules/:module/settings", async (c) => {
     const moduleId = c.req.param("module");
-    const body = await c.req.json();
-    for (const [key, value] of Object.entries(body)) {
+    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 });
@@ -4730,8 +4977,8 @@ function waitForListening(server) {
 async function probePort(port, timeoutMs = 1500) {
   try {
     const res = await fetch(`http://127.0.0.1:${port}/api/health`, { signal: AbortSignal.timeout(timeoutMs) });
-    const body = await res.json().catch(() => null);
-    return body?.status === "ok" && typeof body.modules === "number" ? "forge" : "other";
+    const body2 = await res.json().catch(() => null);
+    return body2?.status === "ok" && typeof body2.modules === "number" ? "forge" : "other";
   } catch (err) {
     return err.name === "TimeoutError" ? "unresponsive" : "other";
   }
@@ -4787,6 +5034,7 @@ __export(dist_exports, {
   portInUseMessage: () => portInUseMessage,
   probePort: () => probePort,
   quietSqliteWarning: () => quietSqliteWarning,
+  rememberPrompt: () => rememberPrompt,
   resolveKiokuBin: () => resolveKiokuBin,
   resolveListenOptions: () => resolveListenOptions,
   skillRoutes: () => skillRoutes,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "forge-cw",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "description": "A visual dashboard for your coding agents on Claude Code, Codex, Pi or OpenCode. Installs CW for you.",
   "license": "MIT",
   "type": "module",