@nanhara/hara 0.0.1 → 0.33.0

package/dist/tools/codebase.js

@@ -0,0 +1,102 @@
+// codebase_search — treat the current project as a knowledge base. Lexical relevance search over the
+// repo's code/text (respects .gitignore via listProjectFiles), ranked by how many distinct query words a
+// file contains, returning the densest snippet. Distinct from grep (exact pattern): this finds *related*
+// code from a natural-language query. The interface a semantic (zvec) index slots into later.
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { registerTool } from "./registry.js";
+import { listProjectFiles, isProbablyBinary, fileSize } from "../fs-walk.js";
+import { findProjectRoot } from "../context/agents-md.js";
+import { loadConfig } from "../config.js";
+import { getEmbedder } from "../search/embed.js";
+import { queryIndex, indexExists } from "../search/semindex.js";
+const MAX_FILE = 200_000; // skip very large files
+const CODE_RE = /\.(ts|tsx|js|jsx|mjs|cjs|py|go|rs|java|kt|rb|php|c|h|cc|cpp|hpp|cs|swift|scala|sh|bash|sql|md|mdx|json|ya?ml|toml|html|css|scss|less|vue|svelte|astro|tf|proto|graphql|gql|gradle|txt)$/i;
+registerTool({
+    name: "codebase_search",
+    description: "Find code in THIS project relevant to a natural-language query — ranked by relevance (not exact match). " +
+        "Use it to locate similar/related code while working ('where is auth handled?', 'retry logic'); use grep " +
+        "for exact strings/regex. Returns the top files with their most relevant snippet (file:line).",
+    input_schema: {
+        type: "object",
+        properties: { query: { type: "string" }, limit: { type: "number", description: "default 6 (max 20)" } },
+        required: ["query"],
+    },
+    kind: "read",
+    async run(input, ctx) {
+        const words = [...new Set(String(input.query ?? "").toLowerCase().split(/\s+/).filter((w) => w.length > 1))];
+        if (!words.length)
+            return "(empty query)";
+        const need = Math.min(2, words.length); // require most of the query to actually appear (conceptual overlap)
+        const limit = Math.min(Number(input.limit) || 6, 20);
+        const root = findProjectRoot(ctx.cwd);
+        const hits = [];
+        for (const rel of listProjectFiles(root)) {
+            if (!CODE_RE.test(rel))
+                continue;
+            const abs = join(root, rel);
+            if (fileSize(abs) > MAX_FILE)
+                continue;
+            let buf;
+            try {
+                buf = readFileSync(abs);
+            }
+            catch {
+                continue;
+            }
+            if (isProbablyBinary(buf))
+                continue;
+            const text = buf.toString("utf8");
+            const lower = text.toLowerCase();
+            const present = words.filter((w) => lower.includes(w));
+            if (present.length < need)
+                continue;
+            // densest line = the one matching the most distinct query words; show it with a little context
+            const lines = text.split("\n");
+            let bestLine = 0;
+            let bestHits = 0;
+            for (let i = 0; i < lines.length; i++) {
+                const ll = lines[i].toLowerCase();
+                const h = present.reduce((n, w) => (ll.includes(w) ? n + 1 : n), 0);
+                if (h > bestHits) {
+                    bestHits = h;
+                    bestLine = i;
+                }
+            }
+            const snippet = lines.slice(Math.max(0, bestLine - 2), bestLine + 4).join("\n");
+            hits.push({ file: rel, score: present.length * 100 + bestHits, line: bestLine + 1, snippet });
+        }
+        hits.sort((a, b) => b.score - a.score || a.file.length - b.file.length);
+        // Semantic layer (opt-in): if a repo index + embedder are configured, prepend the most relevant
+        // chunks (more precise than word overlap), then fill remaining slots with lexical hits. Falls back
+        // to pure lexical when no index/embedder — zero behaviour change for the default install.
+        const out = [];
+        const seen = new Set();
+        const cfg = loadConfig();
+        const embed = getEmbedder(cfg);
+        if (embed && indexExists("repo", ctx.cwd)) {
+            try {
+                for (const s of await queryIndex("repo", String(input.query), embed, ctx.cwd, limit)) {
+                    if (s.score < 0.2 || seen.has(s.file))
+                        continue;
+                    seen.add(s.file);
+                    out.push(`${s.file} (semantic ${s.score.toFixed(2)})\n${s.text.split("\n").slice(0, 6).join("\n")}`);
+                }
+            }
+            catch {
+                /* embedding endpoint down → degrade to lexical */
+            }
+        }
+        for (const h of hits) {
+            if (out.length >= limit)
+                break;
+            if (seen.has(h.file))
+                continue;
+            seen.add(h.file);
+            out.push(`${h.file}:${h.line}\n${h.snippet}`);
+        }
+        if (!out.length)
+            return "(no relevant code found)";
+        return out.join("\n\n---\n\n");
+    },
+});

package/dist/tools/computer.js

@@ -0,0 +1,236 @@
+// computer — native screen control (operate desktop software, not just the browser). Shell-out per OS, no
+// heavy deps: mac = screencapture + cliclick · windows = PowerShell + .NET/user32 · linux = scrot + xdotool.
+// Safety: opt-in tier (config computerUse off|read|click|full) + per-app allowlist (config computerApps:
+// frontmost-window check before any pointer/keyboard action) + dangerous-key blocklist + a once-per-session
+// grant (tool kind "computer" always confirms once, even in full-auto). Screenshots are read via the vision
+// sidecar (ctx.describeImage) so a text main model can still "see" them.
+import { spawnSync } from "node:child_process";
+import { existsSync, statSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { registerTool } from "./registry.js";
+import { loadConfig } from "../config.js";
+const RANK = { off: 0, read: 1, click: 2, full: 3 };
+const ACTION_MIN = { screenshot: "read", move: "click", click: "click", type: "full", key: "full" };
+// dangerous combos refused even at full tier (quit / close / delete / task-switch-kill)
+const KEY_BLOCK = /(?:\b(cmd|command|ctrl|control|alt|option|win|super|meta)\b.*\+.*\b(q|w|delete|del|f4|escape|esc)\b)|ctrl\+alt\+(?:delete|del|backspace)/i;
+/** Whether the configured tier permits the action. Exported for tests. */
+export function actionAllowed(tier, action) {
+    return RANK[tier] >= RANK[ACTION_MIN[action] ?? "full"];
+}
+/** Whether a key combo is on the dangerous blocklist. Exported for tests. */
+export function keyIsBlocked(keys) {
+    return KEY_BLOCK.test(keys);
+}
+function run(cmd, args) {
+    try {
+        const r = spawnSync(cmd, args, { encoding: "utf8", timeout: 15000 });
+        return { ok: r.status === 0, out: ((r.stdout || "") + (r.stderr || "")).trim() };
+    }
+    catch (e) {
+        return { ok: false, out: e?.message || "spawn failed" };
+    }
+}
+function has(cmd) {
+    return (process.platform === "win32" ? run("where", [cmd]) : run("which", [cmd])).ok;
+}
+const ps = (script) => run("powershell", ["-NoProfile", "-Command", script]);
+let seq = 0;
+function tmpShot() {
+    seq += 1;
+    return join(tmpdir(), `hara-screen-${process.pid}-${Date.now()}-${seq}.png`);
+}
+function screenshot() {
+    const out = tmpShot();
+    if (process.platform === "darwin") {
+        if (!run("screencapture", ["-x", out]).ok)
+            return { error: "screencapture failed (grant Screen Recording permission)" };
+    }
+    else if (process.platform === "linux") {
+        if (has("scrot"))
+            run("scrot", ["-o", out]);
+        else if (has("import"))
+            run("import", ["-window", "root", out]);
+        else if (has("grim"))
+            run("grim", [out]);
+        else
+            return { error: "no screenshot tool — install scrot / imagemagick / grim" };
+    }
+    else if (process.platform === "win32") {
+        const script = `Add-Type -AssemblyName System.Windows.Forms,System.Drawing; $b=[System.Windows.Forms.Screen]::PrimaryScreen.Bounds; $bmp=New-Object System.Drawing.Bitmap($b.Width,$b.Height); $g=[System.Drawing.Graphics]::FromImage($bmp); $g.CopyFromScreen($b.Location,[System.Drawing.Point]::Empty,$b.Size); $bmp.Save(${JSON.stringify(out)})`;
+        if (!ps(script).ok)
+            return { error: "PowerShell screenshot failed" };
+    }
+    else {
+        return { error: `unsupported platform ${process.platform}` };
+    }
+    try {
+        if (!existsSync(out) || statSync(out).size === 0)
+            return { error: "screenshot produced no file" };
+    }
+    catch {
+        return { error: "screenshot produced no file" };
+    }
+    return { path: out };
+}
+/** Name of the frontmost application/window (for the allowlist check). "" if undetectable. */
+function frontmostApp() {
+    if (process.platform === "darwin") {
+        const r = run("osascript", ["-e", 'tell application "System Events" to get name of first application process whose frontmost is true']);
+        return r.ok ? r.out : "";
+    }
+    if (process.platform === "linux") {
+        const r = run("xdotool", ["getactivewindow", "getwindowclassname"]);
+        return r.ok ? r.out : "";
+    }
+    if (process.platform === "win32") {
+        const script = `Add-Type @"
+using System;using System.Runtime.InteropServices;public class Hw{[DllImport("user32.dll")]public static extern IntPtr GetForegroundWindow();[DllImport("user32.dll")]public static extern int GetWindowThreadProcessId(IntPtr h,out int p);}
+"@; $p=0;[void][Hw]::GetWindowThreadProcessId([Hw]::GetForegroundWindow(),[ref]$p);(Get-Process -Id $p).ProcessName`;
+        const r = ps(script);
+        return r.ok ? r.out : "";
+    }
+    return "";
+}
+function pointerOrKeyboard(action, input) {
+    const x = Math.round(Number(input.x));
+    const y = Math.round(Number(input.y));
+    const mac = process.platform === "darwin";
+    const lin = process.platform === "linux";
+    const win = process.platform === "win32";
+    if (action === "click" || action === "move") {
+        if (!Number.isFinite(x) || !Number.isFinite(y))
+            return { ok: false, msg: `${action} needs x,y` };
+        if (mac) {
+            if (!has("cliclick"))
+                return { ok: false, msg: "cliclick not found — install with `brew install cliclick`" };
+            const r = run("cliclick", [`${action === "click" ? "c" : "m"}:${x},${y}`]);
+            return { ok: r.ok, msg: r.ok ? `${action} at ${x},${y}` : r.out };
+        }
+        if (lin) {
+            if (!has("xdotool"))
+                return { ok: false, msg: "xdotool not found" };
+            const r = run("xdotool", action === "click" ? ["mousemove", `${x}`, `${y}`, "click", "1"] : ["mousemove", `${x}`, `${y}`]);
+            return { ok: r.ok, msg: r.ok ? `${action} at ${x},${y}` : r.out };
+        }
+        if (win) {
+            const move = `Add-Type -AssemblyName System.Windows.Forms;[System.Windows.Forms.Cursor]::Position=New-Object System.Drawing.Point(${x},${y})`;
+            const m1 = ps(`Add-Type -AssemblyName System.Drawing;${move}`);
+            if (action === "click" && m1.ok) {
+                ps(`Add-Type @"
+using System;using System.Runtime.InteropServices;public class Ms{[DllImport("user32.dll")]public static extern void mouse_event(int f,int x,int y,int d,int e);}
+"@; [Ms]::mouse_event(0x2,0,0,0,0);[Ms]::mouse_event(0x4,0,0,0,0)`);
+            }
+            return { ok: m1.ok, msg: m1.ok ? `${action} at ${x},${y}` : m1.out };
+        }
+    }
+    if (action === "type") {
+        const text = String(input.text ?? "");
+        if (!text)
+            return { ok: false, msg: "type needs text" };
+        if (mac) {
+            if (!has("cliclick"))
+                return { ok: false, msg: "cliclick not found — install with `brew install cliclick`" };
+            const r = run("cliclick", [`t:${text}`]);
+            return { ok: r.ok, msg: r.ok ? `typed ${text.length} chars` : r.out };
+        }
+        if (lin) {
+            if (!has("xdotool"))
+                return { ok: false, msg: "xdotool not found" };
+            const r = run("xdotool", ["type", "--clearmodifiers", text]);
+            return { ok: r.ok, msg: r.ok ? `typed ${text.length} chars` : r.out };
+        }
+        if (win) {
+            const r = ps(`Add-Type -AssemblyName System.Windows.Forms;[System.Windows.Forms.SendKeys]::SendWait(${JSON.stringify(text)})`);
+            return { ok: r.ok, msg: r.ok ? `typed ${text.length} chars` : r.out };
+        }
+    }
+    if (action === "key") {
+        const keys = String(input.keys ?? "");
+        if (!keys)
+            return { ok: false, msg: "key needs a key/combo" };
+        if (keyIsBlocked(keys))
+            return { ok: false, msg: `refused dangerous key combo: ${keys}` };
+        if (mac) {
+            if (!has("cliclick"))
+                return { ok: false, msg: "cliclick not found — install with `brew install cliclick`" };
+            const r = run("cliclick", [`kp:${keys}`]);
+            return { ok: r.ok, msg: r.ok ? `pressed ${keys}` : r.out };
+        }
+        if (lin) {
+            if (!has("xdotool"))
+                return { ok: false, msg: "xdotool not found" };
+            const r = run("xdotool", ["key", keys]);
+            return { ok: r.ok, msg: r.ok ? `pressed ${keys}` : r.out };
+        }
+        if (win) {
+            const r = ps(`Add-Type -AssemblyName System.Windows.Forms;[System.Windows.Forms.SendKeys]::SendWait(${JSON.stringify(keys)})`);
+            return { ok: r.ok, msg: r.ok ? `pressed ${keys}` : r.out };
+        }
+    }
+    return { ok: false, msg: `unknown or unsupported action '${action}' on ${process.platform}` };
+}
+/** Per-OS backend availability — for `hara doctor`. */
+export function computerBackends() {
+    if (process.platform === "darwin")
+        return `screencapture ✓ · cliclick ${has("cliclick") ? "✓" : "✗ (brew install cliclick)"}`;
+    if (process.platform === "linux")
+        return `scrot ${has("scrot") ? "✓" : "✗"} · xdotool ${has("xdotool") ? "✓" : "✗"}`;
+    if (process.platform === "win32")
+        return "PowerShell (built-in)";
+    return `unsupported (${process.platform})`;
+}
+registerTool({
+    name: "computer",
+    description: "Control the screen to operate desktop software (not just the browser): take a screenshot, then " +
+        "click/move/type/press keys at coordinates. Workflow: screenshot → read what's on screen → act. " +
+        "Opt-in and permission-gated (tier + per-app allowlist).",
+    input_schema: {
+        type: "object",
+        properties: {
+            action: { type: "string", enum: ["screenshot", "click", "move", "type", "key"] },
+            x: { type: "number", description: "x pixel (click/move)" },
+            y: { type: "number", description: "y pixel (click/move)" },
+            text: { type: "string", description: "text to type (type)" },
+            keys: { type: "string", description: "key or combo, e.g. 'return', 'cmd+c' (key)" },
+        },
+        required: ["action"],
+    },
+    kind: "computer",
+    async run(input, ctx) {
+        const cfg = loadConfig();
+        const tier = cfg.computerUse;
+        if (tier === "off")
+            return "Screen control is off. Enable it: `hara config set computerUse read|click|full` (and `hara config set computerApps \"App Name, …\"` for the click/type allowlist).";
+        const action = String(input.action ?? "");
+        if (!actionAllowed(tier, action))
+            return `'${action}' needs a higher tier (current computerUse=${tier}). Raise it with \`hara config set computerUse …\`.`;
+        if (action !== "screenshot") {
+            // per-app allowlist: only act when an allowlisted app is frontmost (the key guard against wrong-window clicks)
+            if (!cfg.computerApps.length)
+                return "No apps allowlisted — set `hara config set computerApps \"App Name, …\"` before clicking/typing.";
+            const app = frontmostApp();
+            const allowed = cfg.computerApps.some((a) => app.toLowerCase().includes(a.toLowerCase()) || a.toLowerCase().includes(app.toLowerCase()));
+            if (!allowed)
+                return `Refused: frontmost app "${app || "unknown"}" isn't in your allowlist (${cfg.computerApps.join(", ")}). Switch to an allowed app or update computerApps.`;
+        }
+        if (action === "screenshot") {
+            const s = screenshot();
+            if (s.error)
+                return `Screenshot failed: ${s.error}`;
+            if (ctx.describeImage) {
+                try {
+                    const desc = await ctx.describeImage(s.path);
+                    if (desc)
+                        return `Screenshot (read via vision):\n${desc}`;
+                }
+                catch {
+                    /* fall through to path */
+                }
+            }
+            return `Screenshot saved to ${s.path}. Configure a vision model so I can read it: \`hara config set visionModel <model>\`.`;
+        }
+        const r = pointerOrKeyboard(action, input);
+        return r.ok ? `✓ ${r.msg}` : `Failed: ${r.msg}`;
+    },
+});

package/dist/tools/edit.js

@@ -0,0 +1,62 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { isAbsolute, resolve } from "node:path";
+import { registerTool } from "./registry.js";
+import { nearestPaths } from "../fs-walk.js";
+import { emitDiff } from "../diff.js";
+import { applyEdits } from "./apply-core.js";
+import { recordEdit } from "../undo.js";
+registerTool({
+    name: "edit_file",
+    description: "Edit an existing file by replacing exact strings. Provide a single `old_string`/`new_string`, " +
+        "or `edits` (an array of {old_string,new_string,replace_all?}) applied in order. Each `old_string` " +
+        "must match exactly and appear once (include surrounding context) unless `replace_all` is true. " +
+        "Quote variants (straight/curly) are matched leniently. Use write_file to create a new file, or " +
+        "apply_patch to change several files at once.",
+    input_schema: {
+        type: "object",
+        properties: {
+            path: { type: "string" },
+            old_string: { type: "string", description: "exact text to replace (verbatim, incl. whitespace)" },
+            new_string: { type: "string", description: "replacement text" },
+            replace_all: { type: "boolean", description: "replace every occurrence (default false)" },
+            edits: {
+                type: "array",
+                description: "multiple edits applied in sequence (alternative to a single old/new)",
+                items: {
+                    type: "object",
+                    properties: {
+                        old_string: { type: "string" },
+                        new_string: { type: "string" },
+                        replace_all: { type: "boolean" },
+                    },
+                    required: ["old_string", "new_string"],
+                },
+            },
+        },
+        required: ["path"],
+    },
+    kind: "edit",
+    async run(input, ctx) {
+        const p = isAbsolute(input.path) ? input.path : resolve(ctx.cwd, input.path);
+        const edits = Array.isArray(input.edits) && input.edits.length
+            ? input.edits
+            : [{ old_string: input.old_string, new_string: input.new_string, replace_all: input.replace_all }];
+        let text;
+        try {
+            text = await readFile(p, "utf8");
+        }
+        catch {
+            const near = nearestPaths(ctx.cwd, input.path);
+            return `Error: cannot read ${input.path} (use write_file to create a new file).` + (near.length ? ` Did you mean: ${near.join(", ")}?` : "");
+        }
+        const res = applyEdits(text, edits);
+        if ("error" in res)
+            return `Error: ${res.error} in ${input.path}. No changes written.`;
+        await writeFile(p, res.text, "utf8");
+        emitDiff(input.path, text, res.text, ctx.ui);
+        recordEdit([{ path: input.path, absPath: p, before: text }]);
+        const note = res.fuzzy ? " (quote-normalized)" : "";
+        const plural = (n, w) => `${n} ${w}${n === 1 ? "" : "s"}`;
+        return `Edited ${input.path}: ${plural(edits.length, "edit")}, ${plural(res.total, "replacement")}${note}.`;
+    },
+});

package/dist/tools/memory.js

@@ -0,0 +1,147 @@
+// Memory tools — the agent's interface to durable memory. memory_search/get are read-only
+// (parallel-safe, never prompt); memory_write/forget are edits (gated by the approval mode).
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "node:fs";
+import { isAbsolute, resolve, join } from "node:path";
+import { registerTool } from "./registry.js";
+import { searchAssets, assetSearchRoots } from "../recall.js";
+import { searchHybrid } from "../search/hybrid.js";
+import { memoryRoots, appendMemory, replaceMemory, forgetMemory } from "../memory/store.js";
+import { scanMemory, redactSecrets, scrubLocal } from "../memory/guard.js";
+import { globalSkillsDir, skillsDir, invalidateSkillsCache } from "../skills/skills.js";
+const asTarget = (v) => (["memory", "user", "log"].includes(v) ? v : "memory");
+const asScope = (v) => (v === "global" ? "global" : "project");
+registerTool({
+    name: "memory_search",
+    description: "Search your durable memory (facts, decisions, user preferences, daily notes) by keywords. " +
+        "Use BEFORE answering about prior work, project conventions, or the user's preferences.",
+    input_schema: {
+        type: "object",
+        properties: { query: { type: "string" }, limit: { type: "number", description: "default 5" } },
+        required: ["query"],
+    },
+    kind: "read",
+    async run(input, ctx) {
+        const hits = await searchHybrid(String(input.query ?? ""), ctx.cwd, { indexName: "memory", roots: memoryRoots(ctx.cwd), limit: Math.min(Number(input.limit) || 5, 10) });
+        if (!hits.length)
+            return "(no memory matches)";
+        return hits.map((h) => `${h.path} — ${h.title}\n${h.snippet}`).join("\n\n");
+    },
+});
+registerTool({
+    name: "memory_get",
+    description: "Read a memory file in full (use after memory_search to pull the exact entry).",
+    input_schema: { type: "object", properties: { path: { type: "string" } }, required: ["path"] },
+    kind: "read",
+    async run(input, ctx) {
+        const p = isAbsolute(String(input.path)) ? String(input.path) : resolve(ctx.cwd, String(input.path));
+        if (!memoryRoots(ctx.cwd).some((r) => p.startsWith(r)))
+            return `Error: ${input.path} is outside the memory store.`;
+        if (!existsSync(p))
+            return `Error: no memory file at ${p}.`;
+        try {
+            return readFileSync(p, "utf8").slice(0, 50_000);
+        }
+        catch (e) {
+            return `Error: ${e.message}`;
+        }
+    },
+});
+registerTool({
+    name: "memory_write",
+    description: "Persist a durable fact/decision/preference to memory so future sessions recall it. Save proactively " +
+        "when you learn something worth keeping: project conventions, the user's preferences, a tricky solution.",
+    input_schema: {
+        type: "object",
+        properties: {
+            content: { type: "string" },
+            target: { type: "string", enum: ["memory", "user", "log"], description: "memory=durable facts, user=user prefs (global), log=today's note. default memory" },
+            scope: { type: "string", enum: ["project", "global"], description: "default project" },
+            mode: { type: "string", enum: ["append", "replace"], description: "default append" },
+        },
+        required: ["content"],
+    },
+    kind: "edit",
+    async run(input, ctx) {
+        const content = String(input.content ?? "").trim();
+        if (!content)
+            return "Error: empty content.";
+        const scan = scanMemory(content);
+        if (!scan.ok)
+            return `Blocked: this looks unsafe to store (${scan.hits.join(", ")}). Rephrase without secrets/injection text.`;
+        const scope = asScope(input.scope);
+        const target = asTarget(input.target);
+        const f = input.mode === "replace" ? replaceMemory(scope, target, content, ctx.cwd) : appendMemory(scope, target, content, ctx.cwd);
+        return `Saved to ${f}`;
+    },
+});
+registerTool({
+    name: "skill_create",
+    description: "Save a reusable skill (a how-to / capability) as a SKILL.md so you and future sessions can load it " +
+        "later via the `skill` tool. Use after solving something worth reusing. The `description` is how you'll " +
+        "recognize when to load it, so make it specific (what it does + when to use it).",
+    input_schema: {
+        type: "object",
+        properties: {
+            name: { type: "string", description: "short kebab-case skill id" },
+            description: { type: "string", description: "one line: what it does + when to use it" },
+            body: { type: "string", description: "the instructions in Markdown (steps, code, gotchas)" },
+            scope: { type: "string", enum: ["project", "personal"], description: "project = this repo's .hara/skills; personal = ~/.hara/skills (default). Sharing to company/public is a separate, human-confirmed step." },
+        },
+        required: ["name", "description", "body"],
+    },
+    kind: "edit",
+    async run(input, ctx) {
+        const slug = String(input.name ?? "")
+            .toLowerCase()
+            .replace(/[^a-z0-9-]+/g, "-")
+            .replace(/^-+|-+$/g, "")
+            .slice(0, 48);
+        if (!slug)
+            return "Error: invalid name.";
+        let description = String(input.description ?? "").replace(/\s+/g, " ").trim();
+        if (!description)
+            return "Error: a description is required (it's how the skill gets surfaced).";
+        // sanitize on capture: generalize local paths/emails, then redact secrets; block only on residue.
+        description = scrubLocal(description, ctx.cwd);
+        let body = scrubLocal(String(input.body ?? ""), ctx.cwd);
+        const rd = redactSecrets(description);
+        const rb = redactSecrets(body);
+        description = rd.text;
+        body = rb.text;
+        const redactions = [...rd.redactions, ...rb.redactions];
+        const scan = scanMemory(`${description}\n${body}`);
+        if (!scan.ok)
+            return `Blocked: content still looks unsafe (${scan.hits.join(", ")}). Remove injection/exfil text.`;
+        const scope = input.scope === "project" ? "project" : "personal";
+        const dir = join(scope === "project" ? skillsDir(ctx.cwd) : globalSkillsDir(), slug);
+        const f = join(dir, "SKILL.md");
+        // dedup: surface a near-duplicate so the agent updates instead of piling up (lexical signal, not a block)
+        const dups = searchAssets(`${slug} ${description}`, 3, assetSearchRoots(ctx.cwd)).filter((h) => h.path !== f && h.score >= 2);
+        mkdirSync(dir, { recursive: true });
+        writeFileSync(f, `---\nname: ${slug}\ndescription: ${description}\n---\n\n${body.trim()}\n`, "utf8");
+        invalidateSkillsCache();
+        const notes = [
+            redactions.length ? `redacted ${redactions.length} secret(s)` : "",
+            dups.length ? `⚠ similar already exists: ${dups.map((d) => d.path).join(", ")} — consider updating instead` : "",
+        ].filter(Boolean);
+        return `Saved ${scope} skill to ${f}${notes.length ? ` (${notes.join("; ")})` : ""}`;
+    },
+});
+registerTool({
+    name: "memory_forget",
+    description: "Remove memory lines matching a substring (prune stale or wrong facts).",
+    input_schema: {
+        type: "object",
+        properties: {
+            match: { type: "string" },
+            target: { type: "string", enum: ["memory", "user", "log"] },
+            scope: { type: "string", enum: ["project", "global"] },
+        },
+        required: ["match"],
+    },
+    kind: "edit",
+    async run(input, ctx) {
+        const n = forgetMemory(asScope(input.scope), asTarget(input.target), String(input.match ?? ""), ctx.cwd);
+        return n ? `Removed ${n} line(s).` : "(no matching lines)";
+    },
+});