@nurix/etna 0.13.0 → 0.15.1

package/data/harnesses/code/hooks/session-stop.js

@@ -0,0 +1,207 @@
+// harness/code/hooks/session-stop.js — SessionEnd hook: append one cheap session-summary ledger entry.
+
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const { execFileSync } = require("child_process");
+const { redact } = require("./lib/redact.js");
+
+// 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 truncate(text, n) {
+  const clean = String(text || "").replace(/\s+/g, " ").trim();
+  return clean.length > n ? clean.slice(0, n) + "…" : clean;
+}
+
+// Parse the JSONL transcript into a cheap mechanical summary.
+function summarizeTranscript(transcriptPath) {
+  const summary = { firstPrompt: "", assistantTurns: 0, files: new Set(), lastAssistant: "", sawCommit: false };
+  try {
+    if (!transcriptPath || !fs.existsSync(transcriptPath)) return summary;
+    const lines = fs.readFileSync(transcriptPath, "utf8").split("\n");
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      let row;
+      try {
+        row = JSON.parse(line);
+      } catch (e) {
+        continue;
+      }
+      const msg = row && row.message ? row.message : row;
+      const role = (msg && msg.role) || row.type;
+      if (role === "user" && !summary.firstPrompt) {
+        summary.firstPrompt = extractText(msg);
+      }
+      if (role === "assistant") {
+        summary.assistantTurns += 1;
+        const text = extractText(msg);
+        if (text) summary.lastAssistant = text;
+        collectToolUse(msg, summary);
+      }
+    }
+  } catch (e) {
+    // Best-effort summary; ignore parse issues.
+  }
+  return summary;
+}
+
+// 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 "";
+}
+
+// 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;
+    }
+  }
+}
+
+// Compute the ledger day-file path for a given actor and date.
+function ledgerPath(projectDir, date, actor) {
+  const dir = path.join(projectDir, "docs", "memory", "ledger");
+  return { dir, file: path.join(dir, `${date}--${actor}.md`) };
+}
+
+// Build the day-file header block.
+function header(date, actor) {
+  return `# Ledger — ${date} — ${actor}\nAppend-only event ledger. Raw input to distillation — see docs/memory/.\n`;
+}
+
+// Skip if the day-file's last entry was written by this session within the current minute.
+function isDuplicate(file, sessionId, hhmm) {
+  try {
+    if (!sessionId || !fs.existsSync(file)) return false;
+    const text = fs.readFileSync(file, "utf8");
+    const idx = text.lastIndexOf("\n## ");
+    const tail = idx >= 0 ? text.slice(idx) : text;
+    return tail.includes(`session ${sessionId}`) && tail.includes(`## ${hhmm} `);
+  } catch (e) {
+    return false;
+  }
+}
+
+// Main: assemble and append one session-summary entry, never blocking.
+function main() {
+  const raw = readStdin();
+  let payload = {};
+  try {
+    payload = raw ? JSON.parse(raw) : {};
+  } catch (e) {
+    payload = {};
+  }
+
+  const projectDir = resolveProjectDir(payload);
+  const actor = resolveActor(projectDir);
+  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 date = `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())}`;
+  const hhmm = `${pad(now.getHours())}:${pad(now.getMinutes())}`;
+
+  const summary = summarizeTranscript(payload.transcript_path);
+  const sessionId = payload.session_id || "";
+
+  // Nothing meaningful to record (garbage/empty payload, unreadable transcript) → silent no-op.
+  if (summary.assistantTurns === 0 && !summary.firstPrompt) return;
+
+  const { dir, file } = ledgerPath(projectDir, date, actor);
+  if (isDuplicate(file, sessionId, hhmm)) return;
+
+  const type = summary.sawCommit ? "decision" : summary.assistantTurns > 0 ? "action" : "observation";
+  const fileCount = summary.files.size;
+  const whatBits = [];
+  if (summary.firstPrompt) whatBits.push(`task "${truncate(redact(summary.firstPrompt), 100)}"`);
+  whatBits.push(`${summary.assistantTurns} turns`);
+  if (fileCount) whatBits.push(`${fileCount} file${fileCount === 1 ? "" : "s"} edited`);
+  const what = whatBits.join(", ") || "session ended";
+
+  const lines = [`## ${hhmm} · ${actor} · ${repo}@${branch}`, `- type: ${type}`, `- what: ${redact(what)}`];
+  if (summary.lastAssistant) {
+    lines.push(`- why: ${truncate(redact(summary.lastAssistant), 100)}`);
+  }
+  const refs = [];
+  if (sessionId) refs.push(`session ${sessionId}`);
+  if (fileCount) refs.push(`${fileCount} files`);
+  if (refs.length) lines.push(`- refs: ${redact(refs.join(" · "))}`);
+
+  const exists = fs.existsSync(file);
+  fs.mkdirSync(dir, { recursive: true });
+  const block = (exists ? "\n" : header(date, actor) + "\n") + lines.join("\n") + "\n";
+  fs.appendFileSync(file, block, "utf8");
+}
+
+try {
+  main();
+} catch (e) {
+  try {
+    process.stderr.write(`session-stop hook: ${e && e.message ? e.message : e}\n`);
+  } catch (e2) {
+    // Nothing more we can do.
+  }
+} finally {
+  process.exit(0);
+}

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

@@ -1,6 +1,6 @@
 ---
 applyTo: "**"
-plugins: [nurix-harness]
+plugins: [code]
 ---
 
 # Technology Choices & Standards

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

@@ -1,6 +1,6 @@
 ---
 applyTo: "**"
-plugins: [nurix-harness]
+plugins: [code]
 ---
 
 # Nomenclature Guidelines

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

@@ -1,7 +1,7 @@
 ---
 name: boundary
 description: The single home for a repo's typed application boundaries — the cross-cutting contracts (db-schema, wire envelope, store shape, auth, tenancy, event schemas, edge bindings, …) where editing one module silently breaks another. One skill, four modes — `generate` (baseline all boundaries from the detected stack + IA), `create` (add/update one boundary), `check` (pre-implementation: does this plan touch a boundary? severity-ranked impact), `init` (reconcile: ensure files exist, scan live code for violations + drift, backfill new catalog types). All four read one shared knowledge root, `references/boundary-taxonomy.md`, so they can never drift apart. Triggers on "application boundary", "baseline boundaries", "map boundaries", "generate boundaries", "create a boundary", "introspect", "check this plan", "impact analysis", "what could break", "scan for boundary violations", "boundary drift", "/boundary".
-plugins: [nurix-harness]
+plugins: [code]
 ---
 
 # Application Boundary Skill
@@ -83,6 +83,16 @@ instantiate one file per boundary that actually exists.
    checklist (never a transcribed copy — it rots); `transcribe` boundaries (the
    composed store tree, the response envelope, the IA topology, tenancy) get the
    contract canonically in the file.
+   - **Greenfield branch — contract decided, no code yet.** If the repo is
+     pre-code (ADRs/domain-model decide the contract but the source module isn't
+     scaffolded), a `point` boundary has no `file:line` to mirror. Don't skip it
+     and don't fabricate a pointer — per the taxonomy's *Greenfield / pre-code
+     boundaries*, emit it as **conventions-with-planned-pointer**: record the
+     decided conventions inline, carry a `planned <path>` pointer, mark it `point*`
+     (a pre-code `transcribe` source is `transcribe*`), and make the last
+     safe-change item "replace the planned pointer with the real `file:line` once
+     code lands." Link any item that hinges on an unresolved decision to its
+     open-question/ADR.
 4. **Set severity** from the taxonomy default, adjusted by the concrete repo +
    project memory. Severity is load-bearing — it drives `check` review depth and
    `init` scan priority.
@@ -90,8 +100,13 @@ instantiate one file per boundary that actually exists.
    line. The distinct vertices named across all `Bounds` lines are the
    **module-discovery feed** `harness-manager` reads to propose modules — name
    them precisely.
-6. **Write `docs/boundaries/README.md`** as the index: every boundary, its type,
-   severity, and which technology packs are active.
+6. **Write `docs/boundaries/README.md`** as the index per the taxonomy's index
+   spec: a table with a **Doc-mode column**
+   (`| Boundary | Type | Severity | Doc-mode | Bounds (summary) |`), then the
+   standing blocks — **Active technology packs**, **Folds applied** (which catalog
+   types collapsed into which file — surface the per-entry fold-notes as a ledger),
+   and **Skipped** (types omitted + one-line reason each). Add the `point*`/`transcribe*`
+   footnote if any boundary is pre-code.
 7. **Don't invent boundaries the repo doesn't have.** Only instantiate types the
    detected stack/IA actually exhibits; `log()` what you skipped and why.
 
@@ -224,7 +239,10 @@ newly-exhibited boundary types backfilled.
   types; `log()` skips. **A clean report is valid** — empty violations/intersections
   means say so, don't pad.
 - **Docs never outrank code.** For `point` boundaries, mirror with `file:line`;
-  don't fork the shape.
+  don't fork the shape. `file:line` stays primary for point-mode boundaries; an
+  `anchors:` query (see the documentation skill's frontmatter reference) MAY
+  supplement it for refactor-resilience — optional and additive, it re-resolves
+  the shape when the line moves, never replaces the pointer.
 - **Be specific** — file paths, line numbers, boundary names, the exact violating
   string or code shape.