@nurix/etna 0.18.9 → 0.18.11

package/data/harnesses/etna/hooks/lib/redact.mjs

@@ -0,0 +1,35 @@
+// harness/code/hooks/lib/redact.mjs — shared privacy filter: redacts secret shapes before ledger append.
+
+// Patterns ordered most-specific first; each replaces a match with [redacted:{kind}].
+const RULES = [
+  // PEM private/public key blocks (multiline).
+  { kind: "pem", re: /-----BEGIN[\s\S]*?-----END[^-]*-----/g },
+  // OpenAI / Anthropic-style keys (sk-..., sk-ant-...).
+  { kind: "api-key", re: /\bsk-(?:ant-)?[A-Za-z0-9_-]{8,}\b/g },
+  // AWS access key IDs.
+  { kind: "aws-key", re: /\bAKIA[0-9A-Z]{16}\b/g },
+  // Bearer tokens in Authorization context.
+  { kind: "bearer", re: /\bBearer\s+[A-Za-z0-9._~+/=-]{8,}/gi },
+  // password= / passwd= / secret= / token= / api_key= style assignments (= or :).
+  {
+    kind: "credential",
+    re: /\b(?:password|passwd|pwd|secret|token|api[_-]?key|access[_-]?key|client[_-]?secret)\b\s*[:=]\s*["']?[^\s"'&)\]},;[]{3,}/gi,
+  },
+  // Generic long hex/base64 token ONLY in a key-value credential context.
+  {
+    kind: "credential",
+    re: /\b(?:key|auth|cred|credential|signature|sig)\b\s*[:=]\s*["']?[A-Za-z0-9+/=_-]{32,}/gi,
+  },
+];
+
+// Redact secret shapes in arbitrary text; returns a string with placeholders.
+function redact(text) {
+  if (text == null) return "";
+  let out = String(text);
+  for (const rule of RULES) {
+    out = out.replace(rule.re, `[redacted:${rule.kind}]`);
+  }
+  return out;
+}
+
+export { redact };

package/data/harnesses/etna/hooks/prompt-recall.mjs

@@ -0,0 +1,155 @@
+// plugins/code/hooks/prompt-recall.mjs — UserPromptSubmit hook: surface fact-cards relevant to the prompt via qmd BM25; stdout is injected as context.
+
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { execFileSync } from "node:child_process";
+
+const MIN_PROMPT_CHARS = 24;
+const MIN_SCORE = 0.45;
+const MAX_CARDS = 3;
+const MAX_STATEMENT_CHARS = 300;
+const MAX_KEYWORDS = 8;
+
+const STOPWORDS = new Set(
+  "a an and are as at be but by can could do does for from has have how i in is it its me my of on or our should so that the their then there these this to was we what when where which who why will with would you your".split(
+    " ",
+  ),
+);
+
+// Read all of stdin synchronously; returns "" if nothing is piped.
+function readStdin() {
+  try {
+    return fs.readFileSync(0, "utf8");
+  } catch (e) {
+    return "";
+  }
+}
+
+// Resolve the project root: CLAUDE_PROJECT_DIR env, else payload cwd, else process cwd.
+function resolveProjectDir(payload) {
+  return process.env.CLAUDE_PROJECT_DIR || (payload && payload.cwd) || process.cwd();
+}
+
+// Map a qmd://collection/relpath hit URI to the card file under docs/memory/facts/.
+function cardPath(factsDir, fileUri) {
+  return path.join(factsDir, String(fileUri || "").replace(/^qmd:\/\/[^/]+\//, ""));
+}
+
+// A card's atomic statement: the body after frontmatter, whitespace-flattened and clipped.
+function cardStatement(file) {
+  try {
+    const body = fs
+      .readFileSync(file, "utf8")
+      .replace(/^---\n[\s\S]*?\n---\n?/, "")
+      .replace(/\s+/g, " ")
+      .trim();
+    return body.length > MAX_STATEMENT_CHARS ? body.slice(0, MAX_STATEMENT_CHARS) + "…" : body;
+  } catch (e) {
+    return "";
+  }
+}
+
+// Run one qmd search mode against the facts collection; [] on any failure — recall is strictly optional.
+function qmdHits(mode, query, collection) {
+  try {
+    const out = JSON.parse(
+      execFileSync("qmd", [mode, query, "--format", "json", "-n", String(MAX_CARDS + 2), "-c", collection], {
+        encoding: "utf8",
+        timeout: 10000,
+        stdio: ["ignore", "pipe", "ignore"],
+      }),
+    );
+    return Array.isArray(out) ? out : [];
+  } catch (e) {
+    return [];
+  }
+}
+
+// Main: search the facts collection for the prompt and emit unseen high-score cards.
+function main() {
+  if (process.env.ETNA_REFLECT) return;
+
+  const raw = readStdin();
+  let payload = {};
+  try {
+    payload = raw ? JSON.parse(raw) : {};
+  } catch (e) {
+    payload = {};
+  }
+
+  const prompt = String(payload.prompt || "").trim();
+  if (!prompt || prompt.startsWith("/") || prompt.length < MIN_PROMPT_CHARS) return;
+
+  const projectDir = resolveProjectDir(payload);
+  const factsDir = path.join(projectDir, "docs", "memory", "facts");
+  let hasCards = false;
+  try {
+    hasCards = fs.readdirSync(factsDir).some((f) => f.endsWith(".md"));
+  } catch (e) {
+    return;
+  }
+  if (!hasCards) return;
+
+  // BM25 keywords first (fast, strict-AND), vector similarity as the natural-language
+  // fallback (~1s warm) — `qmd query` (LLM expansion + rerank) is too slow to block a prompt.
+  const collection = `${path.basename(projectDir)}-facts`;
+  const keywords = Array.from(
+    new Set(
+      prompt
+        .toLowerCase()
+        .replace(/[^a-z0-9\s_./-]/g, " ")
+        .split(/\s+/)
+        .filter((w) => w.length > 2 && !STOPWORDS.has(w)),
+    ),
+  )
+    .slice(0, MAX_KEYWORDS)
+    .join(" ");
+  let hits = keywords ? qmdHits("search", keywords, collection) : [];
+  if (!hits.length) hits = qmdHits("vsearch", prompt.replace(/\s+/g, " ").slice(0, 300), collection);
+  if (!hits.length) return;
+
+  // Inject each card at most once per session.
+  const sessionKey = String(payload.session_id || "any").replace(/[^a-zA-Z0-9-]/g, "");
+  const stateFile = path.join(os.tmpdir(), `etna-recall-${sessionKey}.txt`);
+  let seen = [];
+  try {
+    seen = fs.readFileSync(stateFile, "utf8").split("\n").filter(Boolean);
+  } catch (e) {
+    seen = [];
+  }
+
+  const fresh = hits
+    .filter((h) => h && h.score >= MIN_SCORE && h.file && !seen.includes(h.file))
+    .slice(0, MAX_CARDS);
+  const lines = [];
+  for (const hit of fresh) {
+    const statement = cardStatement(cardPath(factsDir, hit.file));
+    if (statement) {
+      lines.push(`- ${statement} [${String(hit.file).replace(/^qmd:\/\/[^/]+\//, "docs/memory/facts/")}]`);
+    }
+  }
+  if (!lines.length) return;
+
+  try {
+    fs.appendFileSync(stateFile, fresh.map((h) => h.file).join("\n") + "\n", "utf8");
+  } catch (e) {
+    // Dedupe state is best-effort; a re-injection is harmless.
+  }
+
+  process.stdout.write(
+    `<memory-recall>\nProject memory possibly relevant to this prompt (distilled fact-cards):\n${lines.join("\n")}\n</memory-recall>\n`,
+  );
+}
+
+try {
+  main();
+} catch (e) {
+  try {
+    process.stderr.write(`prompt-recall hook: ${e && e.message ? e.message : e}\n`);
+  } catch (e2) {
+    // Nothing more we can do.
+  }
+} finally {
+  process.exit(0);
+}

package/data/harnesses/etna/hooks/session-reflect.mjs

@@ -0,0 +1,285 @@
+// plugins/code/hooks/session-reflect.mjs — SessionEnd hook: reflect the session into durable lessons (headless haiku pass) appended to the actor's memory inbox.
+
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { execFileSync, spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { redact } from "./lib/redact.mjs";
+
+// ESM has no __filename; derive it from this module's URL for the detached worker re-spawn.
+const __filename = fileURLToPath(import.meta.url);
+
+// A session below all three thresholds carries no lesson worth a model call.
+const MIN_TURNS = 8;
+const MAX_MESSAGE_CHARS = 1500;
+const MAX_DIGEST_CHARS = 80000;
+const MAX_LESSONS = 6;
+
+// Read all of stdin synchronously; returns "" if nothing is piped.
+function readStdin() {
+  try {
+    return fs.readFileSync(0, "utf8");
+  } catch (e) {
+    return "";
+  }
+}
+
+// Resolve the project root: CLAUDE_PROJECT_DIR env, else payload cwd, else process cwd.
+function resolveProjectDir(payload) {
+  return process.env.CLAUDE_PROJECT_DIR || (payload && payload.cwd) || process.cwd();
+}
+
+// Run a git command in projectDir; returns trimmed stdout or fallback on any error.
+function git(projectDir, args, fallback) {
+  try {
+    return execFileSync("git", ["-C", projectDir, ...args], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+    }).trim() || fallback;
+  } catch (e) {
+    return fallback;
+  }
+}
+
+// Slug a raw actor name into kebab-case ASCII.
+function slugActor(name) {
+  return String(name || "")
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+}
+
+// Determine the actor: git user.name (slugged) → $USER → "agent".
+function resolveActor(projectDir) {
+  const fromGit = slugActor(git(projectDir, ["config", "user.name"], ""));
+  if (fromGit) return fromGit;
+  const fromEnv = slugActor(process.env.USER || "");
+  if (fromEnv) return fromEnv;
+  return "agent";
+}
+
+// Truncate a single line to n chars with an ellipsis marker.
+function clip(text, n) {
+  const clean = String(text || "").replace(/\s+/g, " ").trim();
+  return clean.length > n ? clean.slice(0, n) + "…" : clean;
+}
+
+// Extract plain text from a message whose content is a string or content-block array.
+function extractText(msg) {
+  if (!msg || !msg.content) return "";
+  if (typeof msg.content === "string") return msg.content;
+  if (Array.isArray(msg.content)) {
+    return msg.content
+      .filter((b) => b && b.type === "text" && typeof b.text === "string")
+      .map((b) => b.text)
+      .join(" ");
+  }
+  return "";
+}
+
+// Strip harness-injected wrappers so only what the user actually typed survives.
+function stripInjected(text) {
+  return String(text || "")
+    .replace(/<system-reminder>[\s\S]*?<\/system-reminder>/g, "")
+    .replace(/<(local-command-caveat|local-command-stdout|local-command-stderr|command-name|command-message|command-args|command-contents)>[\s\S]*?<\/\1>/g, "")
+    .trim();
+}
+
+// Scan an assistant message's tool_use blocks for edited files and git commits.
+function collectToolUse(msg, summary) {
+  if (!msg || !Array.isArray(msg.content)) return;
+  for (const block of msg.content) {
+    if (!block || block.type !== "tool_use") continue;
+    const name = block.name || "";
+    const input = block.input || {};
+    if (/^(Edit|Write|MultiEdit|NotebookEdit)$/.test(name) && input.file_path) {
+      summary.files.add(input.file_path);
+    }
+    if (name === "Bash" && typeof input.command === "string" && /\bgit\s+commit\b/.test(input.command)) {
+      summary.sawCommit = true;
+    }
+  }
+}
+
+// Walk the JSONL transcript once: turn/edit/commit counts plus a USER/ASSISTANT text digest.
+function digestTranscript(transcriptPath) {
+  const out = { turns: 0, files: new Set(), sawCommit: false, lines: [] };
+  if (!transcriptPath || !fs.existsSync(transcriptPath)) return out;
+  for (const line of fs.readFileSync(transcriptPath, "utf8").split("\n")) {
+    if (!line.trim()) continue;
+    let row;
+    try {
+      row = JSON.parse(line);
+    } catch (e) {
+      continue;
+    }
+    if (row.isSidechain) continue;
+    const msg = row && row.message ? row.message : row;
+    const role = (msg && msg.role) || row.type;
+    if (role === "user") {
+      const text = stripInjected(extractText(msg));
+      if (!text || text.startsWith("Caveat: The messages below")) continue;
+      out.lines.push("USER: " + clip(text, MAX_MESSAGE_CHARS));
+    } else if (role === "assistant") {
+      out.turns += 1;
+      collectToolUse(msg, out);
+      const text = extractText(msg);
+      if (text) out.lines.push("ASSISTANT: " + clip(text, MAX_MESSAGE_CHARS));
+    }
+  }
+  return out;
+}
+
+// Compute the per-actor inbox file path.
+function inboxPath(projectDir, actor) {
+  const dir = path.join(projectDir, "docs", "memory", "inbox");
+  return { dir, file: path.join(dir, `${actor}.md`) };
+}
+
+// True when this session already wrote an inbox entry (SessionEnd re-fires on resume).
+function alreadyReflected(file, sessionId) {
+  try {
+    return Boolean(sessionId) && fs.existsSync(file) && fs.readFileSync(file, "utf8").includes(`session ${sessionId}`);
+  } catch (e) {
+    return false;
+  }
+}
+
+// Build the inbox file header block.
+function inboxHeader(actor) {
+  return `# Memory inbox — ${actor}\nSession lessons awaiting distillation — appended by the session-reflect hook, consumed by \`distiller facts\`.\n`;
+}
+
+// The full output contract sits AFTER the transcript — with it only up front, the model
+// continues the conversation in the transcript instead of reflecting on it.
+const PROMPT_HEADER = [
+  "You are a memory reflector. Below is the transcript of a FINISHED coding session,",
+  "delimited by <transcript> tags. Do not reply to it or continue it — you will be asked",
+  "to extract durable lessons from it after the closing tag.",
+  "",
+  "<transcript>",
+  "",
+].join("\n");
+
+const PROMPT_FOOTER = [
+  "",
+  "</transcript>",
+  "",
+  "The session above is over. Extract ONLY durable lessons a future session in this",
+  "repository would benefit from knowing:",
+  "- corrections or preferences the user stated",
+  "- failures whose root cause was found, with the fix",
+  "- decisions made, with their rationale",
+  "- discovered constraints or non-obvious facts about the project or its tooling",
+  "Rules:",
+  "- Most sessions contain none. If nothing qualifies, output exactly: NONE",
+  `- Otherwise output at most ${MAX_LESSONS} bullets and nothing else — no preamble, no headers.`,
+  '- Each bullet starts with "- [project]" (true of this repo or its tooling) or "- [user]" (true of this user).',
+  "- Each bullet is one complete, self-contained sentence with names and identifiers spelled out.",
+  "- Routine work (commits made, files edited, tasks completed) is NOT a lesson. Never include secrets.",
+].join("\n");
+
+// Hook mode: stash the payload and hand off to a detached worker so session exit is never delayed.
+function hook() {
+  const raw = readStdin();
+  let payload = {};
+  try {
+    payload = raw ? JSON.parse(raw) : {};
+  } catch (e) {
+    payload = {};
+  }
+  if (!payload.transcript_path) return;
+
+  const stash = {
+    projectDir: resolveProjectDir(payload),
+    transcriptPath: payload.transcript_path,
+    sessionId: payload.session_id || "",
+  };
+  const stashFile = path.join(os.tmpdir(), `etna-reflect-${stash.sessionId || process.pid}.json`);
+  fs.writeFileSync(stashFile, JSON.stringify(stash), "utf8");
+  spawn(process.execPath, [__filename, "--worker", stashFile], { detached: true, stdio: "ignore" }).unref();
+}
+
+// Worker mode: filter, digest, run the reflection model, append surviving lessons to the inbox.
+function worker(stashFile) {
+  let stash;
+  try {
+    stash = JSON.parse(fs.readFileSync(stashFile, "utf8"));
+  } finally {
+    try {
+      fs.rmSync(stashFile, { force: true });
+    } catch (e) {
+      // Stale stash files are harmless.
+    }
+  }
+
+  const { projectDir, transcriptPath, sessionId } = stash;
+  const digest = digestTranscript(transcriptPath);
+  if (digest.turns < MIN_TURNS && digest.files.size === 0 && !digest.sawCommit) return;
+
+  const actor = resolveActor(projectDir);
+  const { dir, file } = inboxPath(projectDir, actor);
+  if (alreadyReflected(file, sessionId)) return;
+
+  let text = redact(digest.lines.join("\n"));
+  if (text.length > MAX_DIGEST_CHARS) {
+    text = text.slice(0, 8000) + "\n[... middle of session elided ...]\n" + text.slice(-(MAX_DIGEST_CHARS - 8000));
+  }
+
+  const output = execFileSync("claude", ["-p", "--model", "haiku"], {
+    input: PROMPT_HEADER + text + PROMPT_FOOTER,
+    encoding: "utf8",
+    cwd: os.tmpdir(),
+    env: Object.assign({}, process.env, { ETNA_REFLECT: "1" }),
+    timeout: 240000,
+    maxBuffer: 4 * 1024 * 1024,
+    stdio: ["pipe", "pipe", "ignore"],
+  });
+
+  const lessons = output
+    .split("\n")
+    .map((l) => l.trim())
+    .filter((l) => /^- \[(project|user)\]\s+\S/.test(l))
+    .slice(0, MAX_LESSONS)
+    .map((l) => redact(l));
+  if (!lessons.length) return;
+
+  const repo = path.basename(projectDir);
+  const branch = git(projectDir, ["rev-parse", "--abbrev-ref", "HEAD"], "-");
+  const now = new Date();
+  const pad = (n) => String(n).padStart(2, "0");
+  const stamp = `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())} ${pad(now.getHours())}:${pad(now.getMinutes())}`;
+
+  fs.mkdirSync(dir, { recursive: true });
+  if (alreadyReflected(file, sessionId)) return;
+  const exists = fs.existsSync(file);
+  const block =
+    (exists ? "\n" : inboxHeader(actor) + "\n") +
+    `## ${stamp} · session ${sessionId || "unknown"} · ${repo}@${branch}\n` +
+    lessons.join("\n") +
+    "\n";
+  fs.appendFileSync(file, block, "utf8");
+}
+
+function main() {
+  if (process.env.ETNA_REFLECT) return;
+  const workerIdx = process.argv.indexOf("--worker");
+  if (workerIdx !== -1) {
+    worker(process.argv[workerIdx + 1]);
+  } else {
+    hook();
+  }
+}
+
+try {
+  main();
+} catch (e) {
+  try {
+    process.stderr.write(`session-reflect hook: ${e && e.message ? e.message : e}\n`);
+  } catch (e2) {
+    // Nothing more we can do.
+  }
+} finally {
+  process.exit(0);
+}

package/data/harnesses/etna/rules/general.md

@@ -0,0 +1,86 @@
+# General Standards
+
+## Runtime Versions
+
+- **Node.js:** 22 LTS (latest)
+- **Package manager:** detect from lockfile (`pnpm-lock.yaml` → pnpm, `yarn.lock` → yarn, `package-lock.json` → npm). Don't hardcode one.
+- **PostgreSQL:** 17 · **Redis:** 7.x (latest)
+
+## Recommended Packages
+
+No alternatives. Just use these.
+
+| Package                  | Version   | Use                    | Don't use                  |
+| ------------------------ | --------- | ---------------------- | -------------------------- |
+| react                    | ^19.2.3   | UI components          | -                          |
+| vite                     | ^8.0.0    | Build tool, dev server | webpack, CRA               |
+| tailwindcss              | ^4.1.18   | Styling                | styled-components          |
+| @vitejs/plugin-react-swc | ^4.2.2    | JSX compilation        | @vitejs/plugin-react       |
+| react-router-dom         | ^7.11.0   | Routing                | -                          |
+| @reduxjs/toolkit         | ^2.11.2   | State management       | zustand, jotai             |
+| react-redux              | ^9.2.0    | Redux React bindings   | -                          |
+| axios                    | ^1.13.2   | HTTP requests          | fetch                      |
+| date-fns                 | ^4.1.0    | Date formatting        | moment, dayjs              |
+| @dnd-kit/core            | ^6.3.1    | Drag and drop          | react-beautiful-dnd        |
+| motion                   | ^12.23.26 | Animations             | react-spring               |
+| sonner                   | ^2.0.7    | Toast notifications    | react-toastify             |
+| react-window             | ^2.2.3    | List virtualization    | react-virtualized          |
+| nanoid                   | ^5.1.6    | ID generation          | uuid                       |
+| express                  | ^5.2.1    | HTTP server            | fastify, koa               |
+| drizzle-orm              | latest    | Database ORM           | prisma, sequelize, typeorm |
+| drizzle-kit              | latest    | Schema tooling         | -                          |
+| zod                      | ^4.2.1    | Schema validation      | yup, joi                   |
+| jose                     | ^6.1.3    | JWT handling           | jsonwebtoken               |
+| microdiff                | ^1.5.0    | JSON object diffing    | deep-diff, just-diff       |
+| react18-json-view        | ^0.2.9    | JSON tree view         | react-json-view            |
+| @tiptap/react            | ^3.11.1   | Rich text editor       | slate, quill, draft-js     |
+| shiki                    | ^3.22.0   | Syntax highlighting    | prism, highlight.js        |
+| lucide-react             | ^0.562.0  | Icons                  | react-icons, heroicons     |
+| @pdfme/generator         | ^5.5.8    | PDF generation         | jspdf, pdfkit              |
+| cmdk                     | ^1.1.1    | Command palette        | kbar, ninja-keys           |
+| @monaco-editor/react     | ^4.7.0    | Code editor            | codemirror, ace            |
+| localforage              | ^1.10.0   | Client-side storage    | idb, dexie                 |
+| react-markdown           | ^10.1.0   | Markdown rendering     | marked, markdown-it        |
+| fast-deep-equal          | ^3.1.3    | Deep equality checks   | lodash.isEqual             |
+| @ngneat/falso            | latest    | Fake data generation   | @faker-js/faker, chance    |
+| pino                     | ^10.1.0   | Logging                | winston                    |
+
+## Frontend
+
+Tailwind v4 + shadcn-based UI; conventions below.
+
+- **Build every UI through the `frontend-design` skill** — route the brief through it instead of hand-rolling layouts; it owns the archetype, personality tokens, and `@nurix/components` wiring.
+- **Light mode is the default** — design for the light theme as the default; dark mode is opt-in, never the default.
+- **@nurix/\* are restricted-scope npm packages** — installed from the npm registry, auto-authed by a read token in `~/.npmrc`. Just attempt the install; the token authenticates you automatically. Don't pre-empt or second-guess it. If the install actually fails, flag it to the user — never reach for alternatives, a substitute package, or `npm login`.
+- **@nurix/components** — the UI component library (restricted-scope npm package, pre-built); import by subpath, e.g. `@nurix/components/button`.
+- No components.json / shadcn CLI scaffold (.tsx, not .jsx) — consume the prebuilt library; never `npx shadcn add`.
+- Vite: `@tailwindcss/vite` + `@vitejs/plugin-react-swc`. Pin react / react-dom / react/jsx-runtime / react/jsx-dev-runtime to the app's single copy via `resolve.alias` (@nurix/\* ship nested react — keep one hook dispatcher).
+- Tailwind v4, CSS-only (no tailwind.config.js, no PostCSS): styling runs through the `@tailwindcss/vite` plugin.
+- CSS entry `globals.css`, imports in order — `@import "./personality.css"` (token source) → `@import "tailwindcss"` → the library's `styles.css` — then `@theme inline {…}` mapping vars to tokens.
+- Tokens: CSS vars in `:root, :root[data-theme="light"]` + the archetype selector `[data-style="…"]` (personality.css), consumed as semantic Tailwind tokens (bg-card, text-foreground). Honor the archetype's radius/theme decisions (e.g. re-assert `--radius-*` to 0 for a flat archetype; add `@custom-variant dark` only if the project opts into dark mode, and keep light as the default). The library bundles class-variance-authority, clsx, tailwind-merge.
+- Plus general styling rules (spacing in 2/4/6/8, object-cover, truncate, motion, color tokens — never hardcoded hex in components).
+
+## Express 5.x
+
+```javascript
+app.use(cors({ origin: process.env.FRONTEND_URL }));
+app.use(compression());
+app.use(express.json({ limit: '10mb' }));
+app.use(rateLimit({ windowMs: 15 * 60 * 1000, max: 100 }));
+```
+
+- Middleware order: body parsers → custom middleware → routes → error handlers (centralized, last). Auth via middleware. Use Express Router for modular routes.
+
+## API Response Format
+
+```json
+{
+  "status": 1,
+  "message": "Message sent successfully",
+  "data": { "delivered": [{ "user@example.com": 2 }] }
+}
+```
+
+Error: `{ "status": 0, "message": "Error description", "data": null }`
+
+HTTP codes: `200`, `201` (created), `400`, `401` (not authenticated), `403` (not authorized), `404`, `500`

package/data/harnesses/etna/rules/kb.md

@@ -0,0 +1,13 @@
+# kb.md — Patterns for Obsidian-like Folders
+
+Conventions for any folder that is majority markdown — `docs/`, `research/`, an Obsidian vault, or any knowledge base. Rules grow over time; append new ones below.
+
+## Rules
+
+### 1. Every topic gets a `Readme.md`
+
+When you start documenting a topic, create `Readme.md` as the folder's landing page. Don't use `index.md` or unscoped filenames — `Readme.md` is what readers and tools (GitHub, Obsidian) look for first, and it makes the folder self-introducing.
+
+### 2. Always link documents to each other
+
+When one document references an idea, concept, or topic covered in another, link to it. Wikilinks (`[[other-doc]]`) inside Obsidian-native vaults; relative markdown links (`[label](../other-doc.md)`) elsewhere. If you mention it, you link it — that's how the folder becomes a knowledge graph instead of a pile of files.

package/data/harnesses/etna/rules/nomenclature.md

@@ -0,0 +1,41 @@
+# Nomenclature Guidelines
+
+## Naming Guidelines
+
+- Use descriptive names that reveal intent, purpose, and usage
+- Names should explain why something exists and how it's used
+- Favor clarity over brevity
+- Maintain consistency within the codebase
+- Avoid abbreviations unless they're universally understood
+
+## Naming Styles
+
+- Variables : Use nouns or noun phrases. Examples: `userData`, `firstName`, `paymentStatus`, `configOptions`
+- Functions & Methods : Use verbs or verb phrases that describe the action. Examples: `calculateTotal`, `getUserInfo`, `validateInput`, `sendNotification`
+- Boolean Variables : Prefix with is**, has**, can**, or should**. Examples: `isValid`, `hasPermission`, `canEdit`, `shouldRefresh`
+- Arrays : Use plural nouns. Examples: `users`, `productList`, `errorMessages`, `activeConnections`
+- Classes & Components : Use singular nouns or noun phrases. Examples: `RequestHandler`, `UserProfile`, `PaymentProcessor`, `DataValidator`
+- Constants : Use uppercase with meaningful names. Examples: `DEFAULT_TIMEOUT`, `API_BASE_URL`, `MAX_RETRY_COUNT`, `COLOR_PRIMARY`
+- Event Handlers : Use Prefix with handle or on. Examples: `handleSubmit`, `onUserLogin`, `handleInputChange`, `onPageLoad`
+- Interfaces & Types : Use Consider prefixing with I for interfaces (if preferred). Examples: `IUserData`, `IConfigOptions`, `AuthResponse`, `RequestParams`
+- Promises & Async Functions : Use Consider using future tense or suffixes like Async. Examples: `fetchUserData`, `getUserProfileAsync`, `loadConfigAsync`, `processPayment`
+- File & Folder Structure : Use lowercase with descriptive names. Group by feature or function type. Example: `auth/login_service.js`
+
+## Casing Styles
+
+- camelCase : Used in Variables, function names, method names, property names. Examples: `userData`, `calculateTotal`, `firstName`, `isValidEmail`
+- PascalCase : Used in Class names, component names, type definitions. Examples: `UserProfile`, `DataService`, `AuthProvider`, `RequestHandler`
+- snake_case : Used in File names, folder names. Examples: `user_service`, `api_utils`, `auth_middleware`, `data_models`
+- UPPER_SNAKE_CASE : Used in Constants, environment variables. Examples: `MAX_RETRY_COUNT`, `API_KEY`, `DEFAULT_TIMEOUT`, `COLOR_PRIMARY`
+- kebab-case : Used in URLs, CSS class names, HTML IDs. Examples: `nav-container`, `user-profile`, `button-primary`, `form-wrapper`
+
+## Database
+
+Naming for D1 tables, columns, indexes, and their Drizzle mirrors. (For column **types** — PK shape, timestamp columns — see the Cloudflare D1 Schema rule, not here; this section governs names only.)
+
+- **Tables** : snake_case. Entity / hub tables use the plural noun for the thing they hold. Examples: `users`, `apps`, `devices`, `services`.
+- **Junction (M:N) tables** : name a many-to-many join `<entityA>_<entityB>_map` — **always**, even when the join carries its own columns (a `role`, a secret, a status). The `_map` suffix is the signal that a row is a relationship, not an entity; extra attributes on the join do **not** earn it a standalone noun. Use the **singular** stem of each side, owning/anchor entity first (mirror the existing tables — `app_*`). Examples: `app_user_map` (apps ⨯ users), `app_device_map` (apps ⨯ devices), `app_service_map` (apps ⨯ services).
+  - ❌ Don't invent a "nice" noun for a junction — no `members`, `installs`, `memberships`, `enrolments`. A reviewer should read the table name and know both sides and that it's a join.
+- **Columns** : snake_case. Foreign keys are `<entity>_id` (`user_id`, `app_id`, `device_id`, `service_id`). Booleans follow the boolean rule (`is_*`/`has_*`); timestamps are `created_at` / `updated_at`.
+- **Indexes** : `<table>_<col(s)>_idx`; unique indexes `<table>_<col(s)>_unique`. The composite unique on a junction reads `<table>_<colA>_<colB>_unique` — e.g. `app_user_map_app_user_unique`, `app_device_map_device_app_unique`.
+- **Drizzle mirror** : the exported table object is the camelCase of the snake_case table name (`app_user_map` → `appUserMap`); column TS properties are the camelCase of the column (`created_at` → `createdAt`, `service_key` → `serviceKey`). The snake_case string passed to `sqliteTable("…")` and every index name must match `seed/init.sql` exactly (the G1 schema-parity boundary).

package/data/harnesses/etna/skills/boundary/SKILL.md

@@ -0,0 +1,49 @@
+---
+name: boundary
+description: Boundary diagnostic for implementation plans. Given a plan file, reads the source files the plan touches, identifies the application boundaries they participate in — the cross-cutting contracts (db schema, wire envelope, auth, events, env/config, …) where editing one side silently breaks the other — and reports whether the planned changes would violate any of them, severity-ranked, with suggested plan amendments. Read-only; the report lands in chat. Can also run against a diff or named code area instead of a plan. Triggers on "boundary check", "check this plan", "what could break", "impact analysis", "/boundary".
+---
+
+# Boundary Diagnostic
+
+You diagnose whether a plan's changes would break an application boundary.
+
+A boundary is a contract between two pieces of code (or code and infra) that share an assumption with **no compile-time link** between them: the column a raw SQL string names, the JSON envelope a client unwraps, the event string a dispatcher parses, the env var a deploy script writes. Changing one side ships green and breaks the other silently. Your job is to find those edges in the plan's path _before_ execution.
+
+[`references/boundary-taxonomy.md`](references/boundary-taxonomy.md) is the catalog of boundary types (~170 across persistence, wire/API, frontend, auth/tenancy, async/messaging, config/build, runtime/infra), with per-type severities and safe-change checklists. Read it first — it tells you what to look for; the code tells you what exists.
+
+## Run
+
+**Input:** a plan path (given, or the newest in `docs/history/plans/`) — or a diff / named code area for non-plan work. Everything below is identical either way; a diff's hunks stand in for the plan's steps.
+
+1. **Build the touch list.** Parse the plan's Proposed Changes: files to be created or modified, entities/state added or changed, API changes, anything the author flags as a cross-module contract. Note missing subsections.
+
+2. **Identify the boundaries in the touched code.** Read each touched file (and its immediate imports). Against the taxonomy, list the contracts this code participates in — the schema it queries, the envelope it emits, the events it publishes or parses, the auth checks it sits behind, the env it reads.
+
+3. **Trace the other side.** A boundary has two sides; the danger lives on the one the plan _doesn't_ mention. For each contract, grep the shared name or shape across the repo — the column name in other SQL strings, the response field in client unwrappers, the event kind in subscribers, the route in fetch calls and scripts, the env key in deploy tooling. Record consumers as `file:line`.
+
+4. **Judge each intersection.** Does the planned change alter a shape a traced consumer depends on, break an invariant the code establishes (append-only vocabularies, idempotency keys, fail-closed checks, ordering guarantees), or add a new cross-module edge? Severity:
+   - **CRITICAL** — can corrupt persisted data, or open an auth/money path.
+   - **HIGH** — silent cross-module breakage that would ship green.
+   - **MEDIUM** — drift-prone coupling (string-matched, duplicated constants).
+   - **LOW** — smell. Loud, immediately-visible breakage caps at HIGH.
+
+5. **Report in chat:**
+
+   ```
+   # Boundary check — {plan}
+
+   Touched files read: {N} · Boundaries identified: {N}
+   Violations: {N} ({critical}/{high}/{medium}/{low})
+
+   | # | Boundary | Planned change | Other side (file:line) | Severity |
+
+   ## Suggested plan amendments
+   ## Missing plan subsections
+   ```
+
+## Rules
+
+- **Read-only.** You never edit the plan, the code, or any doc. The user folds your amendments into the plan.
+- **Verify in source.** Never flag from plan text alone — read both sides of every boundary you report, and cite both as `file:line`.
+- **No consumer, no finding.** An intersection with no traced other side isn't a violation; at most note it as a new edge the plan introduces.
+- **A clean report is valid.** Zero violations means say so — don't pad.