packmind 0.1.0

package/dist/dashboard/server.js

@@ -0,0 +1,128 @@
+import * as http from "node:http";
+import * as fs from "node:fs";
+import * as crypto from "node:crypto";
+import { URL } from "node:url";
+import { brain } from "../state/files.js";
+import { loadConfig } from "../state/schema.js";
+import { readTextOr, readJsonOr } from "../util/fs-atomic.js";
+import { parseMap } from "../state/formats.js";
+import { readLedger, totalCost } from "../cost/ledger.js";
+import { computeInsights } from "../cost/insights.js";
+import { VectorStore } from "../recall/store.js";
+import { recall } from "../recall/indexer.js";
+import { LocalEmbedder } from "../recall/embedder.js";
+import { TEMPLATES_DIR } from "../cli/locate.js";
+function send(res, code, type, body) {
+    res.writeHead(code, { "content-type": type, "cache-control": "no-store" });
+    res.end(body);
+}
+function json(res, code, value) {
+    send(res, code, "application/json", JSON.stringify(value));
+}
+function overview(ctx) {
+    const b = brain(ctx.projectRoot);
+    const ledger = readLedger(ctx.projectRoot, ctx.config.model);
+    const map = parseMap(readTextOr(b.map));
+    let files = 0;
+    for (const [, list] of map)
+        files += list.length;
+    const vectors = new VectorStore(b.vectors).size();
+    return {
+        project: ctx.projectRoot.split("/").pop(),
+        model: ledger.model,
+        files,
+        vectors,
+        totals: ledger.totals,
+        cost: totalCost(ledger),
+        sessions: ledger.sessions.slice(-30),
+    };
+}
+function mapEntries(ctx) {
+    const out = [];
+    for (const [section, list] of parseMap(readTextOr(brain(ctx.projectRoot).map))) {
+        for (const e of list)
+            out.push({ section, file: e.file, description: e.description, tokens: e.tokens, cost: e.cost ?? 0 });
+    }
+    return out.sort((a, b) => b.tokens - a.tokens);
+}
+async function handle(req, res, ctx, html) {
+    const url = new URL(req.url ?? "/", "http://localhost");
+    const token = url.searchParams.get("token") ?? req.headers["x-packmind-token"];
+    if (url.pathname === "/") {
+        return send(res, 200, "text/html; charset=utf-8", html.replace("__TOKEN__", ctx.token));
+    }
+    // The logo is public (no token) — favicon uses logo.svg, the header uses the
+    // dark-mode variant (light strokes) so it reads on the dark UI without a badge.
+    if (url.pathname === "/logo.svg") {
+        return send(res, 200, "image/svg+xml", readTextOr(`${TEMPLATES_DIR}/logo.svg`));
+    }
+    if (url.pathname === "/logo-dark.svg") {
+        return send(res, 200, "image/svg+xml", readTextOr(`${TEMPLATES_DIR}/logo-dark.svg`));
+    }
+    // Everything under /api requires the token.
+    if (url.pathname.startsWith("/api/")) {
+        if (token !== ctx.token)
+            return json(res, 401, { error: "unauthorized" });
+        try {
+            if (url.pathname === "/api/overview")
+                return json(res, 200, overview(ctx));
+            if (url.pathname === "/api/insights")
+                return json(res, 200, computeInsights(ctx.projectRoot, ctx.config));
+            if (url.pathname === "/api/map")
+                return json(res, 200, mapEntries(ctx));
+            if (url.pathname === "/api/solutions")
+                return json(res, 200, readJsonOr(brain(ctx.projectRoot).solutions, []));
+            if (url.pathname === "/api/journal")
+                return json(res, 200, { text: readTextOr(brain(ctx.projectRoot).journal).split(/\r?\n/).slice(-200).join("\n") });
+            if (url.pathname === "/api/knowledge")
+                return json(res, 200, { text: readTextOr(brain(ctx.projectRoot).knowledge) });
+            if (url.pathname === "/api/recall") {
+                const q = url.searchParams.get("q") ?? "";
+                if (!q.trim())
+                    return json(res, 200, { hits: [] });
+                const embedder = new LocalEmbedder(ctx.config.recall.embedModel);
+                const hits = await recall(ctx.projectRoot, ctx.config, embedder, q);
+                return json(res, 200, { hits });
+            }
+        }
+        catch (err) {
+            return json(res, 500, { error: err instanceof Error ? err.message : String(err) });
+        }
+    }
+    send(res, 404, "text/plain", "not found");
+}
+function listenOnFreePort(server, start) {
+    return new Promise((resolve, reject) => {
+        let port = start;
+        const tryListen = () => {
+            server.once("error", (err) => {
+                if (err.code === "EADDRINUSE" && port < start + 50) {
+                    port++;
+                    tryListen();
+                }
+                else {
+                    reject(err);
+                }
+            });
+            // SECURITY: bind to loopback only — never exposed to the network.
+            server.listen(port, "127.0.0.1", () => resolve(port));
+        };
+        tryListen();
+    });
+}
+export async function startDashboard(projectRoot, preferredPort = 7878) {
+    const config = loadConfig(brain(projectRoot).config);
+    const token = crypto.randomBytes(16).toString("hex");
+    const ctx = { projectRoot, config, token };
+    const html = fs.readFileSync(`${TEMPLATES_DIR}/dashboard.html`, "utf8");
+    const server = http.createServer((req, res) => {
+        handle(req, res, ctx, html).catch(() => send(res, 500, "text/plain", "error"));
+    });
+    const port = await listenOnFreePort(server, preferredPort);
+    return {
+        url: `http://127.0.0.1:${port}/?token=${token}`,
+        port,
+        token,
+        close: () => server.close(),
+    };
+}

package/dist/guard/path-guard.js

@@ -0,0 +1,26 @@
+import * as path from "node:path";
+/**
+ * Resolve `candidate` and confirm it stays within `root`. Returns the resolved
+ * absolute path, or null if it escapes (path traversal). Never throws.
+ */
+export function confineToRoot(root, candidate) {
+    const base = path.resolve(root);
+    const resolved = path.isAbsolute(candidate)
+        ? path.resolve(candidate)
+        : path.resolve(base, candidate);
+    const rel = path.relative(base, resolved);
+    if (rel === "")
+        return resolved;
+    if (rel.startsWith("..") || path.isAbsolute(rel))
+        return null;
+    return resolved;
+}
+export function withinRoot(root, candidate) {
+    return confineToRoot(root, candidate) !== null;
+}
+/** Equal-path test by full resolution (avoids suffix-match false positives). */
+export function samePath(root, a, b) {
+    const ra = confineToRoot(root, a);
+    const rb = confineToRoot(root, b);
+    return ra !== null && rb !== null && ra === rb;
+}

package/dist/guard/secrets.js

@@ -0,0 +1,29 @@
+import * as path from "node:path";
+/**
+ * Files whose contents must never be ingested into PackMind's brain files, and
+ * which the write guard can optionally hard-block. Matched against the basename,
+ * case-insensitively, as simple globs (`*` and `?`).
+ */
+export const SECRET_GLOBS = [
+    ".env", ".env.*", "*.env",
+    "*.pem", "*.key", "*.p8", "*.p12", "*.pfx", "*.ppk",
+    "*.keystore", "*.jks", "*.cer", "*.crt", "*.der",
+    "id_rsa*", "id_dsa*", "id_ecdsa*", "id_ed25519*",
+    "credentials", "credentials.*", ".netrc", ".npmrc", ".pypirc",
+    "*.secret", "*.secrets", "secrets.*", "service-account*.json",
+    "*.kdbx", "*.gpg", "*.asc",
+];
+function toRegExp(glob) {
+    const body = glob
+        .replace(/[.+^${}()|[\]\\]/g, "\\$&")
+        .replace(/\*/g, ".*")
+        .replace(/\?/g, ".");
+    return new RegExp(`^${body}$`, "i");
+}
+const compiled = SECRET_GLOBS.map(toRegExp);
+export function looksSecret(filePath, extraGlobs = []) {
+    const base = path.basename(filePath);
+    if (compiled.some((re) => re.test(base)))
+        return true;
+    return extraGlobs.map(toRegExp).some((re) => re.test(base));
+}

package/dist/hooks/post-read.js

@@ -0,0 +1,80 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = __importStar(require("node:path"));
+const runtime_js_1 = require("./runtime.js");
+function extractContent(input) {
+    const resp = input.tool_response ?? input.tool_output;
+    if (typeof resp === "string")
+        return resp;
+    if (resp && typeof resp === "object") {
+        const c = resp.content ?? resp.text ?? resp.output ?? resp.file?.content;
+        if (typeof c === "string")
+            return c;
+        if (Array.isArray(c))
+            return c.map((x) => (typeof x === "string" ? x : x?.text ?? "")).join("");
+    }
+    return "";
+}
+async function main() {
+    (0, runtime_js_1.requireState)();
+    const root = (0, runtime_js_1.projectRoot)();
+    const input = (0, runtime_js_1.parseInput)(await (0, runtime_js_1.readStdin)());
+    const filePath = input?.tool_input?.file_path;
+    if (!filePath)
+        process.exit(0);
+    const rel = path.relative(root, path.resolve(root, filePath)).split(path.sep).join("/");
+    if (rel.startsWith(".packmind/"))
+        process.exit(0);
+    const content = extractContent(input);
+    if (!content)
+        process.exit(0);
+    const session = (0, runtime_js_1.readSession)();
+    if (!session)
+        process.exit(0);
+    const rec = session.reads[rel];
+    if (!rec)
+        process.exit(0);
+    const cfg = (0, runtime_js_1.hookConfig)();
+    const tokens = (0, runtime_js_1.estimateTokens)(content, filePath);
+    const cost = (0, runtime_js_1.inputCost)(cfg.model, tokens);
+    // Account the delta vs. whatever we previously attributed to this read.
+    session.inputTokens += tokens - rec.tokens;
+    session.inputCost += cost - rec.cost;
+    rec.tokens = tokens;
+    rec.cost = cost;
+    (0, runtime_js_1.writeSession)(session);
+}
+main().catch(() => process.exit(0));

package/dist/hooks/post-write.js

@@ -0,0 +1,107 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const runtime_js_1 = require("./runtime.js");
+function refreshMap(rel, content, model) {
+    const map = (0, runtime_js_1.parseMap)((0, runtime_js_1.readText)((0, runtime_js_1.brainPath)("map.md")));
+    const dir = path.posix.dirname(rel);
+    const section = dir === "." ? "./" : dir + "/";
+    const file = path.posix.basename(rel);
+    const tokens = (0, runtime_js_1.estimateTokens)(content, rel);
+    const entry = {
+        file,
+        description: (0, runtime_js_1.describeLite)(file, content),
+        tokens,
+        cost: (0, runtime_js_1.inputCost)(model, tokens),
+    };
+    if (!map.has(section))
+        map.set(section, []);
+    const list = map.get(section);
+    const idx = list.findIndex((e) => e.file === file);
+    if (idx >= 0) {
+        if (!entry.description && list[idx].description)
+            entry.description = list[idx].description;
+        list[idx] = entry;
+    }
+    else {
+        list.push(entry);
+    }
+    let count = 0;
+    for (const [, l] of map)
+        count += l.length;
+    (0, runtime_js_1.writeText)((0, runtime_js_1.brainPath)("map.md"), (0, runtime_js_1.serializeMap)(map, { fileCount: count, updated: new Date().toISOString() }));
+    return tokens;
+}
+async function main() {
+    (0, runtime_js_1.requireState)();
+    const root = (0, runtime_js_1.projectRoot)();
+    const cfg = (0, runtime_js_1.hookConfig)();
+    const input = (0, runtime_js_1.parseInput)(await (0, runtime_js_1.readStdin)());
+    const ti = input.tool_input ?? {};
+    const filePath = ti.file_path;
+    if (!filePath)
+        process.exit(0);
+    const abs = path.resolve(root, filePath);
+    const rel = path.relative(root, abs).split(path.sep).join("/");
+    if (rel.startsWith(".packmind/"))
+        process.exit(0);
+    if ((0, runtime_js_1.looksSecret)(path.basename(filePath), cfg.extraSecretGlobs))
+        process.exit(0);
+    let content = "";
+    try {
+        content = fs.readFileSync(abs, "utf8");
+    }
+    catch {
+        /* file may have been deleted */
+    }
+    const action = input.tool_name || "edit";
+    const tokens = content ? refreshMap(rel, content, cfg.model) : 0;
+    (0, runtime_js_1.appendLine)((0, runtime_js_1.brainPath)("journal.md"), `| ${new Date().toISOString().slice(11, 16)} | ${action} | \`${rel}\` | ~${tokens} |\n`);
+    if (cfg.recallEnabled && content)
+        (0, runtime_js_1.enqueueRecall)(rel);
+    const session = (0, runtime_js_1.readSession)() ?? (0, runtime_js_1.newSession)("s-adhoc");
+    delete session.reads[rel]; // a write invalidates the prior read-dedupe guard
+    session.writes.push({ file: rel, action, tokens, at: new Date().toISOString() });
+    session.editCounts[rel] = (session.editCounts[rel] ?? 0) + 1;
+    session.outputTokens += tokens;
+    session.outputCost += (0, runtime_js_1.outputCost)(cfg.model, tokens);
+    (0, runtime_js_1.writeSession)(session);
+    if (session.editCounts[rel] >= 4) {
+        (0, runtime_js_1.emitContext)("PostToolUse", `You've edited \`${rel}\` ${session.editCounts[rel]} times this session — consider a different approach and record the lesson via the \`remember\` tool.`);
+    }
+}
+main().catch(() => process.exit(0));

package/dist/hooks/pre-read.js

@@ -0,0 +1,94 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const runtime_js_1 = require("./runtime.js");
+function mtime(p) {
+    try {
+        return fs.statSync(p).mtimeMs;
+    }
+    catch {
+        return 0;
+    }
+}
+async function main() {
+    (0, runtime_js_1.requireState)();
+    const root = (0, runtime_js_1.projectRoot)();
+    const input = (0, runtime_js_1.parseInput)(await (0, runtime_js_1.readStdin)());
+    const filePath = input?.tool_input?.file_path;
+    if (!filePath)
+        process.exit(0);
+    const abs = path.resolve(root, filePath);
+    const rel = path.relative(root, abs).split(path.sep).join("/");
+    if (rel.startsWith(".packmind/"))
+        process.exit(0);
+    const session = (0, runtime_js_1.readSession)() ?? (0, runtime_js_1.newSession)("s-adhoc");
+    const notes = [];
+    const cur = mtime(abs);
+    const prior = session.reads[rel];
+    // Re-read warning only when the file is unchanged since the last read.
+    if (prior && prior.count > 0 && cur > 0 && cur <= prior.mtime) {
+        session.dedupedReads++;
+        notes.push(`Already read \`${rel}\` this session and it's unchanged (~${prior.tokens} tok) — re-reading is usually wasteful.`);
+    }
+    // Map lookup with exact path comparison.
+    const map = (0, runtime_js_1.parseMap)((0, runtime_js_1.readText)((0, runtime_js_1.brainPath)("map.md")));
+    let described = false;
+    for (const [section, entries] of map) {
+        for (const e of entries) {
+            const entryRel = (section === "./" ? "" : section) + e.file;
+            if ((0, runtime_js_1.samePath)(root, path.resolve(root, entryRel), abs)) {
+                if (e.description)
+                    notes.push(`map.md: \`${rel}\` — ${e.description} (~${e.tokens} tok)`);
+                described = true;
+                break;
+            }
+        }
+        if (described)
+            break;
+    }
+    described ? session.mapHits++ : session.mapMisses++;
+    session.reads[rel] = {
+        count: (prior?.count ?? 0) + 1,
+        tokens: prior?.tokens ?? 0,
+        cost: prior?.cost ?? 0,
+        mtime: cur,
+        first: prior?.first ?? new Date().toISOString(),
+    };
+    (0, runtime_js_1.writeSession)(session);
+    (0, runtime_js_1.emitContext)("PreToolUse", notes.join(" "));
+}
+main().catch(() => process.exit(0));

package/dist/hooks/pre-write.js

@@ -0,0 +1,101 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = __importStar(require("node:path"));
+const runtime_js_1 = require("./runtime.js");
+function pendingContent(input) {
+    const ti = input.tool_input ?? {};
+    return [ti.content, ti.new_string, ti.new_str].filter((x) => typeof x === "string").join("\n");
+}
+async function main() {
+    (0, runtime_js_1.requireState)();
+    const root = (0, runtime_js_1.projectRoot)();
+    const input = (0, runtime_js_1.parseInput)(await (0, runtime_js_1.readStdin)());
+    const filePath = input?.tool_input?.file_path;
+    if (!filePath)
+        process.exit(0);
+    const rel = path.relative(root, path.resolve(root, filePath)).split(path.sep).join("/");
+    const content = pendingContent(input);
+    const cfg = (0, runtime_js_1.hookConfig)();
+    const policy = (0, runtime_js_1.readJson)((0, runtime_js_1.brainPath)("policy.json"), { rules: [] });
+    const { findings, block } = (0, runtime_js_1.evaluateWrite)(policy.rules, {
+        relPath: rel,
+        content,
+        blockSecrets: cfg.blockSecrets,
+        extraSecretGlobs: cfg.extraSecretGlobs,
+    });
+    if (block) {
+        const reasons = findings.filter((f) => f.severity === "block").map((f) => f.message).join(" ");
+        (0, runtime_js_1.emitDeny)(`PackMind guardrail blocked this write to \`${rel}\`: ${reasons}`);
+        return;
+    }
+    const notes = findings.map((f) => `Guardrail (${f.ruleId}): ${f.message}`);
+    // Surface known solutions relevant to this file (by recorded file or by path
+    // keyword overlap with the solution's error/tags) so a past fix resurfaces
+    // before re-debugging.
+    const solutions = (0, runtime_js_1.readJson)((0, runtime_js_1.brainPath)("solutions.json"), []);
+    if (solutions.length) {
+        const pathTokens = new Set((rel.toLowerCase().match(/[a-z0-9]{4,}/g) ?? []));
+        const relevant = solutions
+            .map((s) => {
+            let score = 0;
+            if (s.file && s.file === rel)
+                score += 5;
+            const hay = `${s.error ?? ""} ${(s.tags ?? []).join(" ")}`.toLowerCase();
+            for (const w of hay.match(/[a-z0-9]{4,}/g) ?? [])
+                if (pathTokens.has(w))
+                    score += 1;
+            return { s, score };
+        })
+            .filter((x) => x.score >= 2)
+            .sort((a, b) => b.score - a.score)
+            .slice(0, 2);
+        for (const { s } of relevant) {
+            notes.push(`Known solution for this area — ${s.error}${s.fix ? ` → ${s.fix}` : ""}`);
+        }
+    }
+    // Surface relevant Never-Do notes from knowledge.md.
+    if (content) {
+        for (const entry of (0, runtime_js_1.parseNeverDo)((0, runtime_js_1.readText)((0, runtime_js_1.brainPath)("knowledge.md")))) {
+            const token = entry.match(/[`"']([^`"']{2,})[`"']/)?.[1];
+            if (token && new RegExp(`\\b${token.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`).test(content)) {
+                notes.push(`knowledge.md Never-Do: "${entry}"`);
+            }
+        }
+    }
+    if (notes.length)
+        (0, runtime_js_1.emitContext)("PreToolUse", notes.join(" "));
+}
+main().catch(() => process.exit(0));

package/dist/hooks/prompt-submit.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const runtime_js_1 = require("./runtime.js");
+function keywords(text) {
+    return (text.toLowerCase().match(/[a-z0-9_]{4,}/g) ?? []).slice(0, 40);
+}
+/**
+ * Lightweight LEXICAL recall in the hook (semantic recall lives in the MCP
+ * server). Surfaces previously-recorded solutions that share keywords with the
+ * user's prompt, so a known fix resurfaces even before Claude calls a tool.
+ */
+async function main() {
+    (0, runtime_js_1.requireState)();
+    const input = (0, runtime_js_1.parseInput)(await (0, runtime_js_1.readStdin)());
+    const prompt = typeof input.prompt === "string" ? input.prompt : "";
+    if (!prompt)
+        process.exit(0);
+    const kws = new Set(keywords(prompt));
+    if (kws.size === 0)
+        process.exit(0);
+    const solutions = (0, runtime_js_1.readJson)((0, runtime_js_1.brainPath)("solutions.json"), []);
+    const scored = solutions
+        .map((s) => {
+        const hay = keywords([s.error, s.cause, s.fix, ...(s.tags ?? [])].filter(Boolean).join(" "));
+        const overlap = hay.filter((w) => kws.has(w)).length;
+        return { s, overlap };
+    })
+        .filter((x) => x.overlap >= 2)
+        .sort((a, b) => b.overlap - a.overlap)
+        .slice(0, 3);
+    if (scored.length === 0)
+        process.exit(0);
+    const lines = scored.map(({ s }) => `• ${s.error ?? s.id}${s.fix ? ` → fix: ${s.fix}` : ""}`);
+    (0, runtime_js_1.emitContext)("UserPromptSubmit", "PackMind found related past solutions:\n" + lines.join("\n") +
+        "\n(Use the `recall` MCP tool for a deeper semantic search.)");
+}
+main().catch(() => process.exit(0));