opensquid 0.5.395

package/dist/system-export.js

@@ -0,0 +1,194 @@
+/**
+ * `opensquid export / import` — entire ~/.opensquid/ state bundle.
+ *
+ * Used to back up everything the engine writes (codexes, lessons,
+ * memories with .vec sidecars, hooks state under sessions/, project
+ * ID cards, engine config) into a single portable archive. Re-import
+ * on a fresh machine restores identical state.
+ *
+ * Format: tar.gz via system `tar` (bsdtar on macOS / Windows 10+,
+ * GNU tar on Linux — all support `-czf` / `-xzf`). Reasoning: zero
+ * new dependency, deterministic byte layout, easy to inspect via
+ * `tar tzf`. Encryption deferred — pass through gpg externally for
+ * now (`gpg -c <archive>`).
+ *
+ * Round-trip semantics:
+ * - export writes tar.gz containing the entire ~/.opensquid/ tree
+ *   relative to $HOME so paths remain portable across machines
+ * - import accepts --merge (default — extracts on top of existing
+ *   ~/.opensquid/, last-write-wins per file) or --replace (wipe
+ *   ~/.opensquid/ first then extract). Vector index .vec sidecars
+ *   carry through; engine rehydrates the in-memory HNSW on next
+ *   spawn from those sidecars.
+ *
+ * Failure modes:
+ * - missing tar binary → throw with install-tar hint
+ * - existing output path → refuse without --force
+ * - tar exit non-zero → propagate stderr
+ * - --replace on non-empty ~/.opensquid/ + missing input archive → no
+ *   data loss because we extract to a tmp dir first then atomic rename
+ */
+import { spawn } from "node:child_process";
+import { promises as fs } from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+export class SystemExportError extends Error {
+    hint;
+    constructor(message, hint) {
+        super(message);
+        this.hint = hint;
+        this.name = "SystemExportError";
+    }
+}
+/** Resolved data root — `LOOP_HOME` env override, else `~/.opensquid/`. */
+function dataRoot() {
+    return process.env.LOOP_HOME ?? path.join(os.homedir(), ".opensquid");
+}
+/** Default output filename for `export` — timestamped under cwd. */
+function defaultOutputPath() {
+    const ts = new Date().toISOString().replace(/[:.]/g, "-").replace(/T/g, "_");
+    return path.resolve(`opensquid-${ts}.tar.gz`);
+}
+export async function exportSystem(opts = {}) {
+    const root = opts.dataRoot ?? dataRoot();
+    const output = opts.output ? path.resolve(opts.output) : defaultOutputPath();
+    // Verify the data root exists.
+    try {
+        const stat = await fs.stat(root);
+        if (!stat.isDirectory()) {
+            throw new SystemExportError(`data root is not a directory: ${root}`, "set LOOP_HOME or pass --root to override");
+        }
+    }
+    catch (err) {
+        if (err instanceof SystemExportError)
+            throw err;
+        throw new SystemExportError(`data root does not exist: ${root}`, "nothing to export — opensquid hasn't written any state on this machine yet");
+    }
+    // Refuse to overwrite an existing output unless --force.
+    let outputExists = false;
+    try {
+        await fs.access(output);
+        outputExists = true;
+    }
+    catch {
+        /* doesn't exist, fine */
+    }
+    if (outputExists && !opts.force) {
+        throw new SystemExportError(`output path already exists: ${output}`, "pass --force to overwrite, or pick a different --output");
+    }
+    // tar -czf <output> -C <parent-of-root> <basename-of-root>
+    // Bundling by basename keeps the extracted tree at .opensquid/ on
+    // import regardless of what the source machine had as $HOME. The -C
+    // flag chdirs before reading so the archive doesn't carry absolute
+    // paths.
+    const parent = path.dirname(root);
+    const base = path.basename(root);
+    await runTar(["-czf", output, "-C", parent, base]);
+    const stat = await fs.stat(output);
+    return { output, size_bytes: stat.size };
+}
+export async function importSystem(opts) {
+    const root = opts.dataRoot ?? dataRoot();
+    const mode = opts.mode ?? "merge";
+    const input = path.resolve(opts.input);
+    // Verify the input archive exists + is readable.
+    try {
+        const stat = await fs.stat(input);
+        if (!stat.isFile()) {
+            throw new SystemExportError(`input is not a file: ${input}`, "pass an opensquid export archive (tar.gz)");
+        }
+    }
+    catch (err) {
+        if (err instanceof SystemExportError)
+            throw err;
+        throw new SystemExportError(`input archive does not exist: ${input}`, "check the path");
+    }
+    // Validate the archive looks like an opensquid export by listing
+    // contents and looking for the .opensquid/ root entry.
+    const list = await tarList(input);
+    const hasRoot = list.some((entry) => entry.startsWith(".opensquid/") || entry === ".opensquid");
+    if (!hasRoot) {
+        throw new SystemExportError(`input does not look like an opensquid export (no .opensquid/ entry)`, "exports created by `opensquid export` always have a .opensquid/ root");
+    }
+    // For replace mode: extract to a tmp dir first, then atomic rename
+    // over the destination. This way a corrupt input doesn't leave the
+    // user with a half-deleted data root.
+    if (mode === "replace") {
+        const stagingParent = path.join(os.tmpdir(), `opensquid-import-${Date.now()}`);
+        await fs.mkdir(stagingParent, { recursive: true });
+        try {
+            await runTar(["-xzf", input, "-C", stagingParent]);
+            const stagedRoot = path.join(stagingParent, path.basename(root));
+            // Ensure the staged tree exists.
+            await fs.access(stagedRoot);
+            // Wipe the destination + atomic-replace.
+            await fs.rm(root, { recursive: true, force: true });
+            await fs.rename(stagedRoot, root);
+        }
+        finally {
+            // Best-effort cleanup of the staging parent (it's empty now if
+            // the rename succeeded, but may contain orphans on failure).
+            await fs.rm(stagingParent, { recursive: true, force: true }).catch(() => undefined);
+        }
+    }
+    else {
+        // Merge: extract directly to the destination's parent. tar will
+        // create / overwrite files within .opensquid/. Existing files not
+        // in the archive are preserved. Directory must exist.
+        await fs.mkdir(path.dirname(root), { recursive: true });
+        await runTar(["-xzf", input, "-C", path.dirname(root)]);
+    }
+    return { input, data_root: root, mode };
+}
+// ---------------------------------------------------------------------
+// tar helpers
+// ---------------------------------------------------------------------
+function runTar(args) {
+    return new Promise((resolve, reject) => {
+        const child = spawn("tar", args, { stdio: ["ignore", "pipe", "pipe"] });
+        let stderr = "";
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk.toString();
+        });
+        child.on("error", (err) => {
+            if (err.code === "ENOENT") {
+                reject(new SystemExportError("tar binary not found on PATH", "install tar (preinstalled on macOS / Linux; Windows 10+ ships bsdtar)"));
+            }
+            else {
+                reject(err);
+            }
+        });
+        child.on("exit", (code) => {
+            if (code === 0)
+                resolve();
+            else
+                reject(new SystemExportError(`tar exited with code ${code}`, stderr.trim() || "no stderr from tar"));
+        });
+    });
+}
+async function tarList(input) {
+    return new Promise((resolve, reject) => {
+        const child = spawn("tar", ["-tzf", input], { stdio: ["ignore", "pipe", "pipe"] });
+        let stdout = "";
+        let stderr = "";
+        child.stdout.on("data", (chunk) => {
+            stdout += chunk.toString();
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk.toString();
+        });
+        child.on("error", (err) => reject(err));
+        child.on("exit", (code) => {
+            if (code === 0) {
+                resolve(stdout
+                    .split("\n")
+                    .map((l) => l.trim())
+                    .filter(Boolean));
+            }
+            else {
+                reject(new SystemExportError(`tar -tzf exited with code ${code}`, stderr.trim() || "no stderr from tar"));
+            }
+        });
+    });
+}
+//# sourceMappingURL=system-export.js.map

package/dist/system-export.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"system-export.js","sourceRoot":"","sources":["../src.legacy/system-export.ts"],"names":[],"mappings":"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"}

package/dist/utterance/classifier.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Pattern-based utterance classifier — categorizes user-said text into
+ * one of: `fact` / `preference` / `correction` / `workflow_lock` /
+ * `none`, with a suggested follow-up action.
+ *
+ * Pure regex catalog. No LLM call. Fast, deterministic, hand-tunable.
+ * The full LLM-driven Stop-hook auto-classifier is task #112; this
+ * tool is agent-invoked per the CLAUDE.md classify-and-act block.
+ *
+ * Output is structured guidance, not an action. The MCP tool returns
+ * { kind, suggested_action, matched, confidence }; the agent then calls
+ * the appropriate downstream tool (memorize, remember, update_memory)
+ * itself.
+ */
+export type UtteranceKind = "fact" | "preference" | "correction" | "workflow_lock" | "none";
+export type UtteranceConfidence = "high" | "medium" | "low";
+export interface UtterancePattern {
+    /** Stable id (e.g. "preference-always"). */
+    id: string;
+    /** Category this pattern signals. */
+    kind: UtteranceKind;
+    /** Regex matched against the utterance text. */
+    pattern: string;
+    /** Confidence level when this pattern fires. */
+    confidence: UtteranceConfidence;
+    /** Short explanation surfaced to the agent. */
+    reason: string;
+}
+/**
+ * Catalog. Ordered by SPECIFICITY — most specific patterns first so the
+ * first match wins. Conservative: a miss is "agent classifies based on
+ * CLAUDE.md instructions anyway", a false-fire is "spurious memorize/
+ * remember call".
+ */
+export declare const UTTERANCE_PATTERNS: UtterancePattern[];
+export interface ClassifyResult {
+    kind: UtteranceKind;
+    /** Recommended next action for the agent. */
+    suggested_action: string;
+    /** Pattern id(s) that matched. */
+    matched: string[];
+    /** Confidence of the strongest hit. */
+    confidence: UtteranceConfidence | null;
+}
+/**
+ * Classify an utterance. Returns the strongest-confidence match's kind
+ * (high > medium > low), all matching pattern ids, and a suggested
+ * downstream action.
+ *
+ * Empty / whitespace input → kind="none".
+ */
+export declare function classifyUtterance(text: string): ClassifyResult;
+//# sourceMappingURL=classifier.d.ts.map

package/dist/utterance/classifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"classifier.d.ts","sourceRoot":"","sources":["../../src.legacy/utterance/classifier.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,YAAY,GAAG,YAAY,GAAG,eAAe,GAAG,MAAM,CAAC;AAE5F,MAAM,MAAM,mBAAmB,GAAG,MAAM,GAAG,QAAQ,GAAG,KAAK,CAAC;AAE5D,MAAM,WAAW,gBAAgB;IAC/B,4CAA4C;IAC5C,EAAE,EAAE,MAAM,CAAC;IACX,qCAAqC;IACrC,IAAI,EAAE,aAAa,CAAC;IACpB,gDAAgD;IAChD,OAAO,EAAE,MAAM,CAAC;IAChB,gDAAgD;IAChD,UAAU,EAAE,mBAAmB,CAAC;IAChC,+CAA+C;IAC/C,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,EAAE,gBAAgB,EAmHhD,CAAC;AAMF,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,aAAa,CAAC;IACpB,6CAA6C;IAC7C,gBAAgB,EAAE,MAAM,CAAC;IACzB,kCAAkC;IAClC,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,uCAAuC;IACvC,UAAU,EAAE,mBAAmB,GAAG,IAAI,CAAC;CACxC;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,CAsB9D"}

package/dist/utterance/classifier.js

@@ -0,0 +1,184 @@
+/**
+ * Pattern-based utterance classifier — categorizes user-said text into
+ * one of: `fact` / `preference` / `correction` / `workflow_lock` /
+ * `none`, with a suggested follow-up action.
+ *
+ * Pure regex catalog. No LLM call. Fast, deterministic, hand-tunable.
+ * The full LLM-driven Stop-hook auto-classifier is task #112; this
+ * tool is agent-invoked per the CLAUDE.md classify-and-act block.
+ *
+ * Output is structured guidance, not an action. The MCP tool returns
+ * { kind, suggested_action, matched, confidence }; the agent then calls
+ * the appropriate downstream tool (memorize, remember, update_memory)
+ * itself.
+ */
+/**
+ * Catalog. Ordered by SPECIFICITY — most specific patterns first so the
+ * first match wins. Conservative: a miss is "agent classifies based on
+ * CLAUDE.md instructions anyway", a false-fire is "spurious memorize/
+ * remember call".
+ */
+export const UTTERANCE_PATTERNS = [
+    // -------------------- CORRECTION (unambiguous, high) --------------------
+    {
+        id: "correction-no-thats-wrong",
+        kind: "correction",
+        pattern: "\\b(no,?\\s+that'?s\\s+wrong|that'?s\\s+(?:not\\s+)?(?:wrong|incorrect))\\b",
+        confidence: "high",
+        reason: "explicit correction phrasing",
+    },
+    {
+        id: "correction-actually",
+        kind: "correction",
+        pattern: "\\b(actually,?\\s+(?:it\\s+should\\s+be|the\\s+(?:right|correct))\\b)",
+        confidence: "high",
+        reason: "actually-it-should-be retraction pattern",
+    },
+    {
+        id: "correction-i-meant",
+        kind: "correction",
+        pattern: "\\b(I\\s+(?:meant|misspoke)|let me correct that)\\b",
+        confidence: "medium",
+        reason: "self-correction pattern",
+    },
+    // -------------------- WORKFLOW_LOCK (specific, high) --------------------
+    {
+        id: "workflow-the-workflow-is",
+        kind: "workflow_lock",
+        pattern: "\\bthe\\s+workflow\\s+is\\b",
+        confidence: "high",
+        reason: "explicit workflow declaration",
+    },
+    {
+        id: "workflow-pre-research-first",
+        kind: "workflow_lock",
+        pattern: "\\b(always|never)\\s+(pre-?research|audit|test|build)\\s+(first|before|after)\\b",
+        confidence: "high",
+        reason: "phase-ordering directive",
+    },
+    {
+        id: "workflow-no-hedges",
+        kind: "workflow_lock",
+        pattern: "\\bno\\s+(hedges|later\\s+hedges|skip(?:ping)?\\s+phases)\\b",
+        confidence: "high",
+        reason: "explicit anti-drift directive",
+    },
+    {
+        id: "workflow-keep-iterating",
+        kind: "workflow_lock",
+        pattern: "\\bkeep\\s+iterat(?:ing|e)\\s+until\\b",
+        confidence: "medium",
+        reason: "iteration-discipline directive",
+    },
+    // -------------------- PREFERENCE (specific, high — narrower than \"always\") --------------------
+    {
+        id: "preference-i-prefer",
+        kind: "preference",
+        pattern: "\\bI\\s+prefer\\s+",
+        confidence: "high",
+        reason: "explicit preference",
+    },
+    {
+        id: "preference-always-i",
+        kind: "preference",
+        // "always [verb]" attached to first-person (I always, we always)
+        pattern: "\\b(?:I|we|you should)\\s+always\\b",
+        confidence: "high",
+        reason: "first-person always-directive",
+    },
+    {
+        id: "preference-always-action",
+        kind: "preference",
+        // "always [verb]" at sentence start — e.g. "Always run X" or "always X before Y"
+        pattern: "(?:^|\\.\\s+)always\\s+\\w+",
+        confidence: "medium",
+        reason: "sentence-leading always-directive",
+    },
+    {
+        id: "preference-never",
+        kind: "preference",
+        pattern: "\\b(?:I|we|you should)\\s+never\\b|(?:^|\\.\\s+)never\\s+\\w+",
+        confidence: "high",
+        reason: "negative directive",
+    },
+    {
+        id: "preference-dont",
+        kind: "preference",
+        pattern: "(?:^|\\.\\s+)don'?t\\s+\\w+",
+        confidence: "medium",
+        reason: "sentence-leading prohibition",
+    },
+    // -------------------- FACT (broadest, conservative) --------------------
+    {
+        id: "fact-i-use",
+        kind: "fact",
+        pattern: "\\bI\\s+use\\s+\\w+",
+        confidence: "high",
+        reason: "I-use-X declarative",
+    },
+    {
+        id: "fact-x-is-my",
+        kind: "fact",
+        pattern: "\\b\\w+\\s+is\\s+my\\s+\\w+",
+        confidence: "high",
+        reason: "X-is-my-Y identity statement",
+    },
+    {
+        id: "fact-we-have",
+        kind: "fact",
+        pattern: "\\b(?:we\\s+have|our\\s+\\w+\\s+(?:is|uses))\\b",
+        confidence: "medium",
+        reason: "team-attribute statement",
+    },
+];
+/**
+ * Classify an utterance. Returns the strongest-confidence match's kind
+ * (high > medium > low), all matching pattern ids, and a suggested
+ * downstream action.
+ *
+ * Empty / whitespace input → kind="none".
+ */
+export function classifyUtterance(text) {
+    if (!text || !text.trim()) {
+        return { kind: "none", suggested_action: "", matched: [], confidence: null };
+    }
+    const matches = [];
+    for (const p of UTTERANCE_PATTERNS) {
+        try {
+            if (new RegExp(p.pattern, "i").test(text))
+                matches.push(p);
+        }
+        catch {
+            // bad pattern — skip
+        }
+    }
+    if (matches.length === 0) {
+        return { kind: "none", suggested_action: "", matched: [], confidence: null };
+    }
+    const winner = pickStrongest(matches);
+    return {
+        kind: winner.kind,
+        suggested_action: suggestedAction(winner.kind),
+        matched: matches.map((m) => m.id),
+        confidence: winner.confidence,
+    };
+}
+function pickStrongest(matches) {
+    const order = { high: 3, medium: 2, low: 1 };
+    return matches.reduce((best, p) => (order[p.confidence] > order[best.confidence] ? p : best));
+}
+function suggestedAction(kind) {
+    switch (kind) {
+        case "fact":
+            return "call `memorize` with the fact. Note the memory id in your reply.";
+        case "preference":
+            return 'call `memorize` AND `remember` to create a lesson candidate. Reply: "Captured as a candidate rule — promote to permanent?"';
+        case "workflow_lock":
+            return "call `memorize` AND `remember` (workflow rules are high-priority lesson candidates). Offer to promote.";
+        case "correction":
+            return "call `memorize` with the correction. If it supersedes a specific prior memory you can identify, also call `update_memory`.";
+        case "none":
+            return "";
+    }
+}
+//# sourceMappingURL=classifier.js.map

package/dist/utterance/classifier.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"classifier.js","sourceRoot":"","sources":["../../src.legacy/utterance/classifier.ts"],"names":[],"mappings":"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"}

package/dist/utterance/classifier.test.js

@@ -0,0 +1,147 @@
+import { describe, expect, it } from "vitest";
+import { classifyUtterance, UTTERANCE_PATTERNS } from "./classifier.js";
+describe("classifyUtterance — fact", () => {
+    it("matches 'I use pnpm'", () => {
+        const r = classifyUtterance("I use pnpm in this project.");
+        expect(r.kind).toBe("fact");
+        expect(r.matched).toContain("fact-i-use");
+    });
+    it("matches 'Gianna is my daughter'", () => {
+        const r = classifyUtterance("Gianna is my daughter.");
+        expect(r.kind).toBe("fact");
+        expect(r.matched).toContain("fact-x-is-my");
+    });
+    it("matches 'we have postgres in prod'", () => {
+        const r = classifyUtterance("We have postgres in prod and redis for cache.");
+        expect(r.kind).toBe("fact");
+    });
+});
+describe("classifyUtterance — preference", () => {
+    it("matches 'I prefer kebab-case'", () => {
+        const r = classifyUtterance("I prefer kebab-case for file names.");
+        expect(r.kind).toBe("preference");
+        expect(r.matched).toContain("preference-i-prefer");
+    });
+    it("matches 'I always run tests before pushing'", () => {
+        const r = classifyUtterance("I always run tests before pushing.");
+        expect(r.kind).toBe("preference");
+        expect(r.matched).toContain("preference-always-i");
+    });
+    it("matches sentence-leading 'Always check atoms/'", () => {
+        const r = classifyUtterance("Always check atoms/ before creating a new component.");
+        expect(r.kind).toBe("preference");
+    });
+    it("matches 'never amend a commit'", () => {
+        const r = classifyUtterance("Never amend a commit unless the user asks.");
+        expect(r.kind).toBe("preference");
+    });
+    it("matches sentence-leading 'don't push without OK'", () => {
+        const r = classifyUtterance("Don't push without explicit user OK.");
+        expect(r.kind).toBe("preference");
+    });
+});
+describe("classifyUtterance — correction", () => {
+    it("matches 'no, that's wrong'", () => {
+        const r = classifyUtterance("No, that's wrong — the file is at src/foo.ts.");
+        expect(r.kind).toBe("correction");
+        expect(r.matched).toContain("correction-no-thats-wrong");
+    });
+    it("matches 'actually it should be X'", () => {
+        const r = classifyUtterance("Actually, it should be the other way around.");
+        expect(r.kind).toBe("correction");
+    });
+    it("matches 'I meant Y'", () => {
+        const r = classifyUtterance("I meant the v0.4 branch, not v0.3.");
+        expect(r.kind).toBe("correction");
+    });
+});
+describe("classifyUtterance — workflow_lock", () => {
+    it("matches 'the workflow is pre-research → learn → ...'", () => {
+        const r = classifyUtterance("The workflow is pre-research, then learn, then code.");
+        expect(r.kind).toBe("workflow_lock");
+        expect(r.matched).toContain("workflow-the-workflow-is");
+    });
+    it("matches 'always pre-research first'", () => {
+        const r = classifyUtterance("Always pre-research first.");
+        expect(r.kind).toBe("workflow_lock");
+    });
+    it("matches 'no hedges'", () => {
+        const r = classifyUtterance("No hedges — execute the plan.");
+        expect(r.kind).toBe("workflow_lock");
+    });
+    it("matches 'keep iterating until perfect'", () => {
+        const r = classifyUtterance("Keep iterating until we have the perfect solution.");
+        expect(r.kind).toBe("workflow_lock");
+    });
+});
+describe("classifyUtterance — none", () => {
+    it("returns none for empty input", () => {
+        expect(classifyUtterance("").kind).toBe("none");
+        expect(classifyUtterance("   ").kind).toBe("none");
+    });
+    it("returns none for an unremarkable question", () => {
+        const r = classifyUtterance("What's the status of the build?");
+        expect(r.kind).toBe("none");
+        expect(r.matched).toHaveLength(0);
+    });
+    it("returns none for a passive declarative without first-person", () => {
+        // "the system was rebuilt yesterday" — neither preference nor fact
+        // about the user; should not falsely match.
+        const r = classifyUtterance("The system was rebuilt yesterday.");
+        expect(r.kind).toBe("none");
+    });
+});
+describe("false-positive resistance", () => {
+    it("'it always rains here' is NOT a preference", () => {
+        // Metaphorical/passive "always" — no first-person directive.
+        const r = classifyUtterance("It always rains here in November.");
+        expect(r.kind).not.toBe("preference");
+    });
+    it("'this is my best work' is NOT classified as a fact about identity", () => {
+        // "X is my Y" with non-noun "best work" — currently this WOULD
+        // match. Documenting the false-positive case for future tightening.
+        // For MVP we accept this since memorize is light-touch.
+        const r = classifyUtterance("This is my best work.");
+        // Just verify it doesn't crash — kind may be fact or none.
+        expect(["fact", "none"]).toContain(r.kind);
+    });
+});
+describe("confidence ranking", () => {
+    it("returns the highest-confidence match's kind when multiple fire", () => {
+        // "I always prefer X" matches both preference-i-prefer (high) and
+        // preference-always-i (high). Either kind is preference. Result
+        // should be preference.
+        const r = classifyUtterance("I always prefer kebab-case.");
+        expect(r.kind).toBe("preference");
+        expect(r.confidence).toBe("high");
+    });
+});
+describe("suggested_action populated for each kind", () => {
+    it("fact suggests memorize", () => {
+        expect(classifyUtterance("I use pnpm.").suggested_action).toContain("memorize");
+    });
+    it("preference suggests memorize AND remember", () => {
+        const r = classifyUtterance("I prefer X.");
+        expect(r.suggested_action).toContain("memorize");
+        expect(r.suggested_action).toContain("remember");
+    });
+    it("correction suggests memorize and possibly update_memory", () => {
+        const r = classifyUtterance("No, that's wrong.");
+        expect(r.suggested_action).toContain("memorize");
+        expect(r.suggested_action).toContain("update_memory");
+    });
+});
+describe("catalog sanity", () => {
+    it("every pattern has a valid regex", () => {
+        for (const p of UTTERANCE_PATTERNS) {
+            expect(() => new RegExp(p.pattern, "i")).not.toThrow();
+        }
+    });
+    it("every kind has at least one pattern", () => {
+        const kinds = new Set(UTTERANCE_PATTERNS.map((p) => p.kind));
+        expect(kinds.has("fact")).toBe(true);
+        expect(kinds.has("preference")).toBe(true);
+        expect(kinds.has("correction")).toBe(true);
+        expect(kinds.has("workflow_lock")).toBe(true);
+    });
+});

package/dist/workgraph/events.d.ts

@@ -0,0 +1,12 @@
+import type { Client } from '@libsql/client';
+import type { WgOp } from './types.js';
+/** Deterministic edge identity (beads #4259); unit-separated; `type` intentionally excluded. */
+export declare const edgeKey: (fromId: string, toId: string) => string;
+/** Content-addressed op id over a canonical payload; lamport keeps distinct emits distinct. */
+export declare const makeOpId: (type: string, payload: unknown, lamport: number) => string;
+/**
+ * Fold one op into the `wg_issues`/`wg_edges` projection. Deterministic given op order; safe to
+ * replay (idempotent for edges; LWW for issue fields via `wg_issues.lww`).
+ */
+export declare function applyOp(client: Client, op: WgOp): Promise<void>;
+//# sourceMappingURL=events.d.ts.map

package/dist/workgraph/events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../../src/workgraph/events.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAE7C,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAevC,gGAAgG;AAChG,eAAO,MAAM,OAAO,GAAI,QAAQ,MAAM,EAAE,MAAM,MAAM,KAAG,MACgC,CAAC;AAExF,+FAA+F;AAC/F,eAAO,MAAM,QAAQ,GAAI,MAAM,MAAM,EAAE,SAAS,OAAO,EAAE,SAAS,MAAM,KAAG,MAK1D,CAAC;AAIlB;;;GAGG;AACH,wBAAsB,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CA6CrE"}