create-evda 0.1.9 → 0.1.11

package/lib/measurement-log.mjs

@@ -76,6 +76,9 @@ function oid(bytes) {
   return parts.join(".");
 }
 
+// The TDX verifier (tdx-attestation.mjs) reads Intel's PCK certificate extensions with these.
+export { tlv as derTlv, children as derChildren, oid as derOid };
+
 /** The OIDC issuer and the SAN URIs and emails of a Fulcio leaf, read from its DER. */
 export function certificateIdentity(der) {
   const buf = Buffer.from(der);

package/lib/migrate-people.mjs

@@ -3,7 +3,7 @@
 // The six rules, each implemented once below:
 //   1. The file is copied to <record root>/.backup/people-migration-<YYYY-MM-DD>/ first.
 //   2. Frontmatter is added and nothing below it changes: kind, id (filename slug), schemaVersion,
-//      name (the H1), observations. A file that already has frontmatter is skipped and reported.
+//      name (the H1), observations.
 //   3. One observation per dated H2/H3 heading: text is the heading text, since is its date at the
 //      precision written (day or month). A range uses its start. A year-only heading stays prose.
 //   4. supersededBy only when a heading says it replaces an earlier one AND exactly one earlier
@@ -14,7 +14,12 @@
 //      The owner is provenance owner; the person is provenance person with by naming them.
 //   6. Undated sections stay prose.
 // Before a file is reported done, the bytes after the frontmatter are hashed against the original.
-// A doc with no dated heading is left untouched and reported: a profile needs one observation.
+// A profile needs one observation, so a doc with no dated heading gets one dated the day it is typed,
+// saying no section carries a date yet (HQ-2024: doctor fails an untyped file in a person folder, so
+// every file there has to be typeable). A doc with no H1 takes its name from its file name.
+// A file that already has frontmatter keeps every key it has; only the missing person-profile keys
+// are added below them. One that already says a kind, or is sealed or just noted, is skipped.
+// gather apply runs the same plan on a page it places in a person folder (lib/gather-apply.mjs).
 
 import { createHash } from "node:crypto";
 import { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
@@ -23,6 +28,7 @@ import { findRoot, holderOf, readManifest } from "./manifest.mjs";
 import { readEntry } from "./kinds.mjs";
 import { parseYaml, toYaml } from "./yaml.mjs";
 import { carries, frontmatterOf, heldBy, sealedSections, NOTED, SEALED } from "./circles.mjs";
+import { baseName } from "./person-folders.mjs";
 
 // The lines of a body with every line of a sealed section blanked, so nothing in one becomes an
 // observation, a name or a quote in frontmatter every reader shows (HQ-1414). Line numbers are kept.
@@ -105,18 +111,40 @@ export function speakerQuote(line) {
   return null;
 }
 
-// Plan the frontmatter for one doc. Pure: reads nothing from disk.
-export function planProfile({ fileName, text, owner }) {
+const today = () => { const d = new Date(); return `${d.getFullYear()}-${two(d.getMonth() + 1)}-${two(d.getDate())}`; };
+
+// A file's own frontmatter: its YAML lines and where its body starts, or null when it has none.
+function ownFrontmatter(text) {
+  const lines = text.split("\n");
+  if (lines[0] !== "---") return null;
+  const end = lines.indexOf("---", 1);
+  if (end === -1) return null;
+  return { head: lines.slice(1, end), body: lines.slice(end + 1).join("\n") };
+}
+
+// Plan the frontmatter for one doc. Pure: reads nothing from disk. `date` dates the one observation
+// a doc with no dated heading gets. Returns { entry, frontmatter, bodyAt, notes, problems } where
+// the file becomes frontmatter + the original from byte bodyAt on, or { skip }.
+export function planProfile({ fileName, text, owner, date = today() }) {
   const notes = [];
   // A sealed or just-noted file always has frontmatter, so it is skipped here and never rewritten.
   // EVDA_CARRY_FALSIFY=migrate-people:noted lets a noted one through, as a migration that read past
   // its frontmatter would, to show this skip is what keeps it noted.
   const falsifiedNoted = !carries("migrate-people", NOTED) && frontmatterOf(text)?.[NOTED] === true && !heldBy(frontmatterOf(text), "migrate-people");
-  if (/^---\r?\n/.test(text) && !falsifiedNoted) return { skip: "already has frontmatter" };
-  const lines = openLines(text);
+  let own = null;
+  if (/^---\r?\n/.test(text) && !falsifiedNoted) {
+    own = ownFrontmatter(text);
+    const front = frontmatterOf(text);
+    if (!own || !front) return { skip: "already has frontmatter that does not read as YAML" };
+    if (front.kind !== undefined) return { skip: `already has frontmatter saying kind ${front.kind}` };
+    if (heldBy(front, "migrate-people") || front[SEALED] === true || front[NOTED] === true) return { skip: "already has frontmatter that seals it or holds it noted; never rewritten" };
+  }
+  const body = own ? own.body : text;
+  const bodyAt = own ? Buffer.byteLength(text, "utf8") - Buffer.byteLength(body, "utf8") : 0;
+  const lines = openLines(body);
   const h1 = lines.find((l) => /^# \S/.test(l));
-  if (!h1) return { skip: "has no H1 to take the name from" };
-  const name = h1.slice(2).trim();
+  const name = h1 ? h1.slice(2).trim() : baseName(fileName.replace(/\.md$/i, "")).trim();
+  if (!name) return { skip: "has no H1 and no file name to take the name from" };
   const first = name.split(/\s+/)[0];
   const ownerFirst = String(owner).split(/\s+/)[0];
 
@@ -167,7 +195,11 @@ export function planProfile({ fileName, text, owner }) {
     }
   }
 
-  if (observations.length === 0) return { skip: "has no dated H2 or H3 heading, so there is no observation; left as prose" };
+  // A profile holds at least one observation. With no dated section, the one it gets says so.
+  if (observations.length === 0) {
+    observations.push({ obs: { id: "typed", since: date, text: "Typed as a person profile; none of its sections carries a date yet." }, order: 0 });
+    notes.push(`no dated H2 or H3 heading, so its one observation is dated ${date}, the day it was typed`);
+  }
 
   observations.sort((a, b) => (key(a.obs.since) < key(b.obs.since) ? -1 : key(a.obs.since) > key(b.obs.since) ? 1 : a.order - b.order));
   const entry = {
@@ -177,20 +209,22 @@ export function planProfile({ fileName, text, owner }) {
     name,
     observations: observations.map((o) => o.obs),
   };
-  const frontmatter = `---\n${toYaml(entry)}---\n`;
+  // Keys the file already has stay as they are, above the ones added.
+  const front = own ? frontmatterOf(text) : {};
+  const missing = Object.fromEntries(Object.entries(entry).filter(([k]) => !(k in front)));
+  const kept = own && own.head.length ? `${own.head.join("\n")}\n` : "";
+  const frontmatter = `---\n${kept}${toYaml(missing)}---\n`;
   const problems = readEntry("person-profile", parseYaml(frontmatter.slice(4, -4)), { owner }).problems;
-  return { entry, frontmatter, notes, problems };
+  return { entry, frontmatter, bodyAt, notes, problems };
 }
 
-// The body below a written frontmatter is the original, byte for byte.
-export function bodyMatches(original, written, frontmatter) {
+// The body below a written frontmatter is the original's body (from byte bodyAt), byte for byte.
+export function bodyMatches(original, written, frontmatter, bodyAt = 0) {
   const head = Buffer.from(frontmatter, "utf8");
   if (!written.subarray(0, head.length).equals(head)) return false;
-  return sha256(written.subarray(head.length)) === sha256(original);
+  return sha256(written.subarray(head.length)) === sha256(original.subarray(bodyAt));
 }
 
-const today = () => { const d = new Date(); return `${d.getFullYear()}-${two(d.getMonth() + 1)}-${two(d.getDate())}`; };
-
 // Migrate files. Returns one result per file: { file, status: done|would|skipped|failed, ... }.
 export function migratePeople(files, { dry = false, date = today(), root = null } = {}) {
   const results = [];
@@ -203,7 +237,7 @@ export function migratePeople(files, { dry = false, date = today(), root = null
     const owner = (() => { const h = holderOf(readManifest(recordRoot)); return h.id ?? h.name; })();
     if (!owner) { Object.assign(r, { status: "failed", why: "evda.json names no owner" }); continue; }
     const original = readFileSync(file);
-    const plan = planProfile({ fileName: basename(file), text: original.toString("utf8"), owner });
+    const plan = planProfile({ fileName: basename(file), text: original.toString("utf8"), owner, date });
     if (plan.skip) { Object.assign(r, { status: "skipped", why: plan.skip }); continue; }
     Object.assign(r, { frontmatter: plan.frontmatter, notes: plan.notes, observations: plan.entry.observations.length });
     if (plan.problems.length) { Object.assign(r, { status: "failed", why: `the frontmatter would not read as a person-profile: ${plan.problems.join("; ")}` }); continue; }
@@ -217,14 +251,14 @@ export function migratePeople(files, { dry = false, date = today(), root = null
     }
     copyFileSync(file, r.backup);
     if (sha256(readFileSync(r.backup)) !== sha256(original)) { Object.assign(r, { status: "failed", why: "the backup does not match the original; nothing written" }); continue; }
-    writeFileSync(file, Buffer.concat([Buffer.from(plan.frontmatter, "utf8"), original]));
+    writeFileSync(file, Buffer.concat([Buffer.from(plan.frontmatter, "utf8"), original.subarray(plan.bodyAt)]));
     const written = readFileSync(file);
-    if (!bodyMatches(original, written, plan.frontmatter)) {
+    if (!bodyMatches(original, written, plan.frontmatter, plan.bodyAt)) {
       writeFileSync(file, original);
       Object.assign(r, { status: "failed", why: "the body below the frontmatter did not hash to the original; restored the original" });
       continue;
     }
-    r.bodySha256 = sha256(original);
+    r.bodySha256 = sha256(original.subarray(plan.bodyAt));
     r.status = "done";
   }
   return results;

package/lib/person-folders.mjs

@@ -0,0 +1,90 @@
+// Person folders (HQ-2024): one file per person, named for the person, nothing beside it.
+//
+// A folder whose manifest says `type: person` holds one file per person, named `First Last.md`.
+// Timeline and patterns are sections of that file, never side files, and processing docs live in a
+// sibling `Processing/` folder that the profile links. A record that grows a folder for some people
+// and a file for others, two docs for one person, or a stub that says "redirects to" ends up with
+// updates landing in whichever copy a search hits first, while the other goes stale.
+//
+// The layout rules, read across every person folder in the record at once:
+//   1. no subfolder inside a person folder
+//   2. a parenthetical in a name only when another person file shares the base name
+//      (a short first name counts: Phil Rauch and Philip Rauch)
+//   3. no redirect stubs: a file whose text says it redirects is a second doc for one person
+// Doctor (section 12c) reports each as a failure. The README a preset writes says the same rule.
+//
+// FALSIFIED 2026-10-12: test/person-folders.test.mjs run against origin/main (6fc2610), which had
+// none of these rules -> 7 of 7 failed; the subfolder, lone-parenthetical and redirect-stub records
+// each got "OK  12 check(s)", exit 0 ("actual: 0, expected: 1").
+
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { outsideRecord } from "./record-walk.mjs";
+
+export const PROCESSING_DIR = "Processing";
+export const README_NAME = "README.md";
+
+// The README a preset writes into a person folder it makes. Plain words; it is the rule doctor checks.
+export const PERSON_FOLDER_README = [
+  "# People",
+  "",
+  "One file per person, named `First Last.md`. No folder per person.",
+  "",
+  "- Timeline, patterns and anything else about someone are sections of their file, never side files.",
+  `- A parenthetical goes in a name only when two people share it: \`Sam Lee (school).md\` beside \`Sam Lee (work).md\`.`,
+  `- Processing docs (working through something about a person) go in \`${PROCESSING_DIR}/\` beside this folder, and the person's file links them.`,
+  "- No redirect stubs. When two files turn out to be one person, merge them into one and repoint the links.",
+  "- Each file opens with `kind: person-profile` frontmatter, so `evda doctor` reads it.",
+  "",
+  "`evda doctor` fails a record that breaks any of these.",
+  "",
+].join("\n");
+
+// "Sam Lee (work)" -> "Sam Lee".
+export const baseName = (stem) => stem.replace(/\s*\(.*\)\s*$/, "");
+
+// One name to a reader: the same surname, and one first name starting the other.
+export function sameName(a, b) {
+  const x = a.split(/\s+/).filter(Boolean);
+  const y = b.split(/\s+/).filter(Boolean);
+  if (!x.length || !y.length || x.slice(1).join(" ") !== y.slice(1).join(" ")) return false;
+  const [p, q] = [x[0].toLowerCase(), y[0].toLowerCase()];
+  return p.startsWith(q) || q.startsWith(p);
+}
+
+const REDIRECT = /^>?\s*\**redirect/im;
+const ENTRY = /\.(md|json|ya?ml)$/i;
+
+// The layout problems across `dirs` (absolute paths of every `type: person` folder), with `skip` a
+// set of absolute paths that are not person files (folder manifests, declared views). Returns
+// { problems: [{ path, kind, message }], files } where files counts the person files read.
+export function personFolderProblems(dirs, { skip = new Set() } = {}) {
+  const problems = [];
+  const people = [];
+  for (const d of dirs) {
+    let names;
+    try { names = readdirSync(d).sort(); } catch { continue; }
+    for (const name of names) {
+      if (name.startsWith(".") || outsideRecord(name)) continue;
+      const p = join(d, name);
+      let st;
+      try { st = statSync(p); } catch { continue; }
+      if (st.isDirectory()) {
+        problems.push({ path: p, kind: "folder", message: `is a folder inside a person folder. One file per person, named First Last; timeline and patterns are sections of that file, and processing docs go in ${PROCESSING_DIR}/ beside the person folder, linked from the profile.` });
+        continue;
+      }
+      if (skip.has(p) || name === README_NAME || !ENTRY.test(name)) continue;
+      people.push({ path: p, stem: name.replace(ENTRY, "") });
+    }
+  }
+  for (const { path, stem } of people) {
+    const base = baseName(stem);
+    if (base !== stem && !people.some((o) => o.path !== path && sameName(baseName(o.stem), base))) {
+      problems.push({ path, kind: "parenthetical", message: `carries a parenthetical and no other person file is named ${base}. A parenthetical only tells apart people who share a name; name it ${base}.` });
+    }
+    if (REDIRECT.test(readFileSync(path, "utf8"))) {
+      problems.push({ path, kind: "redirect", message: `is a redirect stub, a second doc for one person. Merge anything in it into the profile it points to, delete it, and repoint its links.` });
+    }
+  }
+  return { problems, files: people.length };
+}

package/lib/plugin-hook.mjs

@@ -0,0 +1,109 @@
+#!/usr/bin/env node
+// The hook entry point inside a Cowork plugin that `evda plugin` builds for one record (HQ-2802).
+//
+// Cowork reads no folder's .claude/settings.json, so the hooks `evda hook install` puts there never
+// run in it; a plugin's hooks/hooks.json does run there. This file is what that hooks.json names:
+//
+//   node evda-hook.mjs keep   <record>   Stop: the record's own keep-record hook
+//   node evda-hook.mjs prompt <record>   UserPromptSubmit: the record's own prompt-filing hook
+//   node evda-hook.mjs guard  <record>   PreToolUse: the read guard the record's settings name
+//
+// It holds no hook logic. It runs the copies `evda hook install` keeps current in the record
+// (.claude/hooks/evda-keep-record.mjs, .claude/hooks/evda-file-prompt.mjs) and the guard command
+// the record's settings register, so the plugin files exactly what a Claude Code session in the
+// record would, and a `evda hook install` or `evda update` reaches the plugin without a rebuild.
+//
+// ONLY IN COWORK. A plugin installed on a claude.ai account also loads in the owner's Claude Code
+// terminal sessions, in every project. There the record's project hooks already run in sessions
+// opened in it, and a session in another project is not the record's: filing it would put work
+// conversations in the day. So it acts only when CLAUDE_CODE_ENTRYPOINT is "local-agent", the
+// value the Claude desktop app gives the Claude Code process behind a Cowork task.
+// EVDA_PLUGIN_HOOKS=always acts everywhere (for tests and an owner who wants it); =never, nowhere.
+//
+// THE RECORD. The path baked in at build time, when it is there. A Cowork task can run in a VM
+// that sees the owner's folders mounted under another path, so when the baked path is missing the
+// record is the one at or above the task's cwd whose folder has the same name.
+//
+// Copied byte for byte into the plugin as scripts/evda-hook.mjs; node: built-ins only, because the
+// plugin is a zip with no packages. Any error of its own exits 0 with no output: a broken hook must
+// never block the owner's message or trap a session.
+
+import { existsSync, readFileSync, realpathSync } from "node:fs";
+import { basename, dirname, join, relative, resolve, isAbsolute } from "node:path";
+import { spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+
+export const HOOK_FILES = { keep: ".claude/hooks/evda-keep-record.mjs", prompt: ".claude/hooks/evda-file-prompt.mjs" };
+const GUARD_MARK = /evda-read-guard\.mjs|\bevda guard\b/;
+
+export function active(env = process.env) {
+  if (env.EVDA_PLUGIN_HOOKS === "never") return false;
+  return env.EVDA_PLUGIN_HOOKS === "always" || env.CLAUDE_CODE_ENTRYPOINT === "local-agent";
+}
+
+function recordAt(from) {
+  let d = resolve(from);
+  for (;;) {
+    if (existsSync(join(d, "evda.json"))) return d;
+    const up = dirname(d);
+    if (up === d) return null;
+    d = up;
+  }
+}
+
+// The record this plugin was built for, as this process sees it, or null.
+export function resolveRecord(baked, cwd) {
+  if (baked && existsSync(join(baked, "evda.json"))) return resolve(baked);
+  if (!cwd) return null;
+  const found = recordAt(cwd);
+  return found && baked && basename(found) === basename(baked) ? found : null;
+}
+
+const inside = (root, p) => { const r = relative(root, resolve(p)); return r === "" || (!r.startsWith("..") && !isAbsolute(r)); };
+
+// One hook event in; { stdout, stderr, code } out. Never throws.
+export function handle(mode, baked, input, env = process.env) {
+  const none = { stdout: "", stderr: "", code: 0 };
+  try {
+    if (!active(env)) return none;
+    let payload;
+    try { payload = JSON.parse(input); } catch { return none; }
+    const root = resolveRecord(baked, payload?.cwd);
+    if (!root) return none;
+    if (mode === "keep" || mode === "prompt") {
+      const hook = join(root, HOOK_FILES[mode]);
+      if (!existsSync(hook)) return none;
+      // The record's hooks find the record from cwd; a Cowork task's cwd may be anywhere.
+      const p = { ...payload, cwd: payload.cwd && inside(root, payload.cwd) ? payload.cwd : root };
+      const r = spawnSync(process.execPath, [hook], { input: JSON.stringify(p), encoding: "utf8", timeout: 25000 });
+      return { stdout: r.stdout ?? "", stderr: "", code: 0 };
+    }
+    if (mode === "guard") {
+      const settings = JSON.parse(readFileSync(join(root, ".claude", "settings.json"), "utf8"));
+      const cmd = (settings?.hooks?.PreToolUse ?? []).flatMap((m) => (m?.hooks ?? []).map((h) => h?.command)).find((c) => typeof c === "string" && GUARD_MARK.test(c));
+      if (!cmd) return none;
+      const r = spawnSync(cmd, { shell: true, input, encoding: "utf8", timeout: 25000 });
+      return { stdout: r.stdout ?? "", stderr: r.stderr ?? "", code: r.status === 2 ? 2 : 0 };
+    }
+    return none;
+  } catch {
+    return none;
+  }
+}
+
+const entry = (() => {
+  try { return process.argv[1] && realpathSync(process.argv[1]) === realpathSync(fileURLToPath(import.meta.url)); } catch { return false; }
+})();
+
+if (entry) {
+  const [mode, baked] = process.argv.slice(2);
+  let input = "";
+  process.stdin.setEncoding("utf8");
+  process.stdin.on("data", (d) => (input += d));
+  process.stdin.on("end", () => {
+    const r = handle(mode, baked, input);
+    if (r.stdout) process.stdout.write(r.stdout);
+    if (r.stderr) process.stderr.write(r.stderr);
+    process.exit(r.code);
+  });
+}

package/lib/plugin.mjs

@@ -0,0 +1,208 @@
+// `evda plugin <dir>`: a Claude plugin for one record, so Claude Cowork reaches it (HQ-2802).
+//
+// Cowork does not start the local servers in claude_desktop_config.json (support.claude.com
+// article 11175166: they "aren't available in Cowork or claude.ai"), and its docs never say it
+// reads a folder's CLAUDE.md, AGENTS.md or .claude/settings.json. It does load a plugin's skills,
+// hooks/hooks.json and a local MCP server the app starts, when the task runs on the owner's
+// computer (claude.com/docs/plugins/platform-support, read 2026-10-21). So a record reaches Cowork
+// only through a plugin, built here for one record with its path baked in:
+//
+//   .claude-plugin/plugin.json   the manifest (claude.com/docs/plugins/build)
+//   .mcp.json                    the record's server: `evda mcp <record>`, by connect.mjs's rule
+//   hooks/hooks.json             Stop, UserPromptSubmit and PreToolUse, each through
+//                                scripts/evda-hook.mjs to the hooks `evda hook install` installs
+//   scripts/evda-hook.mjs        lib/plugin-hook.mjs, copied (the plugin is a zip with no packages)
+//   skills/evda/SKILL.md         the shipped evda skill, its description saying to load the
+//                                operating layer first in every conversation, because Cowork may
+//                                never read AGENTS.md
+//
+// Two rules from the same page shape it. Cowork ignores a server whose `${user_config.*}` has no
+// default, because it does not prompt, so nothing here asks for configuration: the path is baked
+// in. And claude.ai and Cowork refuse a plugin with a top-level bin/, so there is none.
+//
+// The owner uploads the zip in Customize, then Plugins, then Add, then Upload plugin. Exported for
+// `evda adopt` (HQ-2797): buildPlugin(dir, { out }) and uploadLines(result).
+
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
+import { deflateRawSync, inflateRawSync } from "node:zlib";
+import { PACKAGE_ROOT, serverCommand, stableNode, installGuard, SKILL_SOURCE } from "./connect.mjs";
+import { installHook, installPromptHook } from "./hooks.mjs";
+import { filingOf } from "./day-file.mjs";
+import { readManifest } from "./manifest.mjs";
+import { EvdaError } from "./errors.mjs";
+
+export const PLUGIN_SERVER = "evda";
+export const LAUNCHER_SOURCE = join(PACKAGE_ROOT, "lib", "plugin-hook.mjs");
+export const LAUNCHER_REL = "scripts/evda-hook.mjs";
+export const UPLOAD_STEP = "In the Claude app, open Customize, then Plugins, then Add, then Upload plugin, and choose";
+
+const packageVersion = () => JSON.parse(readFileSync(join(PACKAGE_ROOT, "package.json"), "utf8")).version;
+
+// A plugin name is lowercase words joined by hyphens, and permanent: one per record folder.
+export function pluginName(dir) {
+  const slug = basename(resolve(dir)).normalize("NFKD").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40).replace(/-+$/, "");
+  return slug ? `evda-${slug}` : "evda-record";
+}
+
+// One shell word, whatever the path holds: spaces, quotes, $ and backticks included.
+export const shq = (s) => `'${String(s).replace(/'/g, "'\\''")}'`;
+
+// The server command for a plugin. connect.mjs's rule (absolute node and bin when installed
+// somewhere stable), except that the npx form is pinned to this version and names npx by its
+// absolute path with a PATH that finds node: the desktop app starts servers with a minimal PATH,
+// and `@latest` would let an uploaded plugin change under the owner.
+export function pluginServerCommand(dir, { execPath = process.execPath, bin, env = process.env, version = packageVersion() } = {}) {
+  const rec = resolve(dir);
+  const c = serverCommand(rec, { execPath, env, ...(bin ? { bin } : {}) });
+  if (c.command !== "npx") return { command: c.command, args: c.args };
+  const node = stableNode(execPath, env);
+  const npx = join(dirname(node), process.platform === "win32" ? "npx.cmd" : "npx");
+  const sep = process.platform === "win32" ? ";" : ":";
+  const path = [dirname(node), ...(process.platform === "win32" ? [] : ["/opt/homebrew/bin", "/usr/local/bin", "/usr/bin", "/bin"])].join(sep);
+  return { command: existsSync(npx) ? npx : "npx", args: ["-y", "-p", `create-evda@${version}`, "evda", "mcp", rec], env: { PATH: path } };
+}
+
+// A hook command in shell form, the form every Claude Code version runs. The node this was built
+// with when it is there, else whatever `node` the hook's PATH has (a Cowork VM, another machine).
+export function hookCommand(mode, dir, { execPath = process.execPath, env = process.env } = {}) {
+  const node = stableNode(execPath, env);
+  return `n=${shq(node)}; [ -x "$n" ] || n=node; "$n" "\${CLAUDE_PLUGIN_ROOT}/${LAUNCHER_REL}" ${mode} ${shq(resolve(dir))}`;
+}
+
+function skillText() {
+  const shipped = readFileSync(SKILL_SOURCE, "utf8");
+  const body = shipped.replace(/^---\n[\s\S]*?\n---\n/, "");
+  const description = "Use at the start of every conversation and every task, before your first reply: call evda_operating_layer from this plugin's evda server and follow it for the whole session, because it says who you are for the owner and how their EVÐA record is kept. Also use whenever they talk about their day, a person, what is on their mind, or say evda, Iris, my record, journal this or log this. Files their words verbatim through the evda_* tools and never quizzes.";
+  return `---\nname: evda\ndescription: ${description}\n---\n${body}`;
+}
+
+// The plugin's files, as { relative path: string }.
+export function pluginFiles(dir, opts = {}) {
+  const rec = resolve(dir);
+  const manifest = readManifest(rec);
+  const filing = filingOf(manifest);
+  const name = pluginName(rec);
+  const version = opts.version ?? packageVersion();
+  const server = pluginServerCommand(rec, { ...opts, version });
+  const hook = (mode, timeout, matcher) => ({ ...(matcher ? { matcher } : {}), hooks: [{ type: "command", command: hookCommand(mode, rec, opts), timeout }] });
+  const hooks = {
+    Stop: [hook("keep", 30)],
+    PreToolUse: [hook("guard", 30, "Read|Grep|Bash|NotebookRead")],
+    // The prompt hook files every message, so only an owner who chose "everything" gets it (HQ-1385).
+    ...(filing === "everything" ? { UserPromptSubmit: [hook("prompt", 15)] } : {}),
+  };
+  const owner = typeof manifest.owner === "string" ? manifest.owner : manifest.owner?.name;
+  return {
+    ".claude-plugin/plugin.json": JSON.stringify({
+      name,
+      displayName: `EVÐA: ${basename(rec)}`,
+      version,
+      description: `Reach the EVÐA record at ${rec} from Cowork: its evda tools, the hooks that keep it, and the skill that loads its operating layer first.`,
+      author: { name: owner || "EVÐA" },
+    }, null, 2) + "\n",
+    ".mcp.json": JSON.stringify({ mcpServers: { [PLUGIN_SERVER]: { type: "stdio", ...server } } }, null, 2) + "\n",
+    "hooks/hooks.json": JSON.stringify({ hooks }, null, 2) + "\n",
+    [LAUNCHER_REL]: readFileSync(LAUNCHER_SOURCE, "utf8"),
+    "skills/evda/SKILL.md": skillText(),
+    "README.md": `# ${name}\n\nThis plugin connects Claude Cowork to one EVÐA record, the folder at \`${rec}\` on this computer. It starts that record's evda MCP server, so Claude can read the record and file the owner's words into it verbatim, and it runs the record's own hooks in Cowork tasks: the one that asks before a task ends with nothing filed${filing === "everything" ? ", the one that files each message as it is sent" : ""}, and the read guard. Nothing leaves this computer through it. Rebuild it with \`evda plugin\` if the folder moves.\n`,
+  };
+}
+
+// CRC-32 (IEEE), for the zip.
+const CRC = (() => { const t = new Uint32Array(256); for (let n = 0; n < 256; n++) { let c = n; for (let k = 0; k < 8; k++) c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1; t[n] = c >>> 0; } return t; })();
+function crc32(buf) { let c = 0xffffffff; for (const b of buf) c = CRC[(c ^ b) & 0xff] ^ (c >>> 8); return (c ^ 0xffffffff) >>> 0; }
+
+// A zip of { path: string|Buffer }, deflated, paths at the archive root.
+export function zip(files) {
+  const locals = [];
+  const centrals = [];
+  let offset = 0;
+  for (const [path, content] of Object.entries(files)) {
+    const data = Buffer.isBuffer(content) ? content : Buffer.from(content, "utf8");
+    const comp = deflateRawSync(data);
+    const name = Buffer.from(path, "utf8");
+    const crc = crc32(data);
+    const local = Buffer.alloc(30);
+    local.writeUInt32LE(0x04034b50, 0); local.writeUInt16LE(20, 4); local.writeUInt16LE(0x0800, 6); local.writeUInt16LE(8, 8);
+    local.writeUInt16LE(0, 10); local.writeUInt16LE(0x21, 12); local.writeUInt32LE(crc, 14); local.writeUInt32LE(comp.length, 18);
+    local.writeUInt32LE(data.length, 22); local.writeUInt16LE(name.length, 26); local.writeUInt16LE(0, 28);
+    const central = Buffer.alloc(46);
+    central.writeUInt32LE(0x02014b50, 0); central.writeUInt16LE(0x0314, 4); central.writeUInt16LE(20, 6); central.writeUInt16LE(0x0800, 8);
+    central.writeUInt16LE(8, 10); central.writeUInt16LE(0, 12); central.writeUInt16LE(0x21, 14); central.writeUInt32LE(crc, 16);
+    central.writeUInt32LE(comp.length, 20); central.writeUInt32LE(data.length, 24); central.writeUInt16LE(name.length, 28);
+    central.writeUInt32LE(((0o100644) << 16) >>> 0, 38); central.writeUInt32LE(offset, 42);
+    locals.push(local, name, comp);
+    centrals.push(central, name);
+    offset += 30 + name.length + comp.length;
+  }
+  const cd = Buffer.concat(centrals);
+  const end = Buffer.alloc(22);
+  const count = Object.keys(files).length;
+  end.writeUInt32LE(0x06054b50, 0); end.writeUInt16LE(count, 8); end.writeUInt16LE(count, 10);
+  end.writeUInt32LE(cd.length, 12); end.writeUInt32LE(offset, 16);
+  return Buffer.concat([...locals, cd, end]);
+}
+
+// The entries of a zip this module wrote, as { path: Buffer }. For tests and doctor-style checks.
+export function unzip(buf) {
+  const out = {};
+  const endAt = buf.lastIndexOf(Buffer.from([0x50, 0x4b, 0x05, 0x06]));
+  if (endAt < 0) throw new Error("not a zip");
+  let p = buf.readUInt32LE(endAt + 16);
+  const count = buf.readUInt16LE(endAt + 10);
+  for (let i = 0; i < count; i++) {
+    if (buf.readUInt32LE(p) !== 0x02014b50) throw new Error("bad central directory");
+    const method = buf.readUInt16LE(p + 10), csize = buf.readUInt32LE(p + 20), nlen = buf.readUInt16LE(p + 28);
+    const xlen = buf.readUInt16LE(p + 30), clen = buf.readUInt16LE(p + 32), at = buf.readUInt32LE(p + 42);
+    const name = buf.subarray(p + 46, p + 46 + nlen).toString("utf8");
+    const dataAt = at + 30 + buf.readUInt16LE(at + 26) + buf.readUInt16LE(at + 28);
+    const raw = buf.subarray(dataAt, dataAt + csize);
+    out[name] = method === 8 ? inflateRawSync(raw) : Buffer.from(raw);
+    p += 46 + nlen + xlen + clen;
+  }
+  return out;
+}
+
+const isOurs = (folder) => {
+  try { return JSON.parse(readFileSync(join(folder, ".claude-plugin", "plugin.json"), "utf8")).name?.startsWith("evda-"); } catch { return false; }
+};
+
+// Build the plugin folder and its zip. `out` is the zip's path (default
+// <record>/.evda/plugin/<name>.zip, which no device sync carries); the folder sits beside it.
+// Installs or refreshes the record's hooks first, so what the plugin points at is current.
+export function buildPlugin(dir, { out = null, ...opts } = {}) {
+  const rec = resolve(dir);
+  if (!existsSync(join(rec, "evda.json"))) throw new EvdaError(`REFUSED: ${rec} has no evda.json, so it is not an EVÐA record. Nothing was written.`, { code: "NOT_A_RECORD", exit: 2 });
+  const name = pluginName(rec);
+  const zipPath = resolve(out ?? join(rec, ".evda", "plugin", `${name}.zip`));
+  if (!zipPath.endsWith(".zip")) throw new EvdaError(`REFUSED: --out names the zip to write, so it ends in .zip (got ${zipPath}). Nothing was written.`, { code: "BAD_OUT", exit: 2 });
+  const folder = zipPath.slice(0, -4);
+  if (existsSync(folder) && readdirSync(folder).length && !isOurs(folder)) throw new EvdaError(`REFUSED: ${folder} already holds something that is not an EVÐA plugin. Nothing was written.`, { code: "OUT_TAKEN", exit: 2 });
+
+  const installed = [installHook(rec).action];
+  installGuard(rec);
+  if (filingOf(readManifest(rec)) === "everything") installed.push(installPromptHook(rec).action);
+
+  const files = pluginFiles(rec, opts);
+  rmSync(folder, { recursive: true, force: true });
+  for (const [rel, content] of Object.entries(files)) {
+    const abs = join(folder, rel);
+    mkdirSync(dirname(abs), { recursive: true });
+    writeFileSync(abs, content);
+  }
+  mkdirSync(dirname(zipPath), { recursive: true });
+  writeFileSync(zipPath, zip(files));
+  return { name, record: rec, folder, zip: zipPath, files: Object.keys(files), bytes: statSync(zipPath).size, hooks: installed };
+}
+
+// What to tell the owner once it is built: the one step left is theirs.
+export function uploadLines(r) {
+  return [
+    `Built the Cowork plugin ${r.name} for ${r.record}:`,
+    `  ${r.zip}`,
+    `${UPLOAD_STEP} that zip. Cowork then reaches this record in tasks that run on this computer, through its evda tools and hooks.`,
+    `It also loads in Claude Code sessions signed in to the same account. Its hooks stay quiet there, because the record's own hooks already run in it; its evda server shows up as a second one, and \`claude plugin disable ${r.name}@synced\` turns the plugin off in Claude Code only. If the folder moves, run \`evda plugin\` again and upload the new zip.`,
+  ];
+}
+