@hawkeyexl/manni 4.3.1 → 4.4.0

package/dist/chunk-YEUYKR62.js

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+import {
+  programName,
+  setProgramName
+} from "./chunk-OWBRDNRZ.js";
+import {
+  ToolError,
+  errorMessage
+} from "./chunk-G3T47CFV.js";
+
+// src/shared/run.ts
+import { realpathSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { CommanderError } from "commander";
+function fail(err) {
+  const msg = err instanceof ToolError ? err.message : `Unexpected error: ${errorMessage(err)}`;
+  const prefix = programName();
+  for (const line of msg.replace(/\n+$/, "").split("\n")) {
+    process.stderr.write(`${prefix}: ${line}
+`);
+  }
+  process.exit(2);
+}
+var STDIN_LINES_MARKER = "\0";
+var STDIN_WITH_LINES = /^-(:[1-9][0-9]*(?:-[1-9][0-9]*)?)$/;
+function normalizeStdinArgv(argv) {
+  return argv.map((arg) => {
+    const lines = STDIN_WITH_LINES.exec(arg)?.[1];
+    return lines === void 0 ? arg : `${STDIN_LINES_MARKER}${lines}`;
+  });
+}
+async function runProgram(program, argv = process.argv) {
+  setProgramName(program.name());
+  try {
+    await program.parseAsync(normalizeStdinArgv(argv));
+  } catch (err) {
+    if (err instanceof CommanderError) {
+      process.exitCode = err.exitCode === 0 ? 0 : 2;
+      return;
+    }
+    throw err;
+  }
+}
+function isMainModule(moduleUrl) {
+  const entry = process.argv[1];
+  if (!entry) return false;
+  try {
+    return realpathSync(entry) === fileURLToPath(moduleUrl);
+  } catch {
+    return false;
+  }
+}
+function endOutputOnClosedReader(streams = [process.stdout, process.stderr]) {
+  for (const stream of streams) {
+    stream.on("error", (err) => {
+      if (err.code === "EPIPE") return;
+      throw err;
+    });
+  }
+}
+function runIfMain(moduleUrl, build) {
+  if (!isMainModule(moduleUrl)) return;
+  endOutputOnClosedReader();
+  Promise.resolve(build()).then(runProgram).catch(fail);
+}
+
+export {
+  fail,
+  STDIN_LINES_MARKER,
+  runIfMain
+};
+//# sourceMappingURL=chunk-YEUYKR62.js.map

package/dist/chunk-YEUYKR62.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/shared/run.ts"],"sourcesContent":["/**\n * Running a commander program as a bin.\n *\n * Every entry point (`manni`, and `docmeta` for existing scripts) is the same\n * three lines: build the program, parse, and turn what escapes into an exit\n * code. Keeping that here means the exit-code contract (0 ok, 1 findings, 2\n * operational/usage) is written once, and the stderr prefix follows the bin\n * that was actually run.\n */\nimport { realpathSync } from \"node:fs\";\nimport { fileURLToPath } from \"node:url\";\nimport { CommanderError, type Command } from \"commander\";\nimport { ToolError, errorMessage } from \"./errors.js\";\nimport { programName, setProgramName } from \"./program-name.js\";\n\n/**\n * Report an operational error on stderr and exit 2.\n *\n * Almost every message is one line. A few name a list the user has to fix in\n * one pass — every seed an `--exclude` pattern contradicts, say — and carry a\n * `\\n` between the lines. Each line gets the prefix, so a second line reads\n * like a message from the tool rather than like wrapped output.\n */\nexport function fail(err: unknown): never {\n  const msg =\n    err instanceof ToolError\n      ? err.message\n      : `Unexpected error: ${errorMessage(err)}`;\n  const prefix = programName();\n  // A trailing newline is the message's own, not a line of its own. Splitting\n  // without dropping it would end the run on a bare `manni: `, which is what\n  // an unexpected error carrying a library's newline-terminated message would\n  // have printed.\n  for (const line of msg.replace(/\\n+$/, \"\").split(\"\\n\")) {\n    process.stderr.write(`${prefix}: ${line}\\n`);\n  }\n  process.exit(2);\n}\n\n/**\n * The marker a normalized stdin-with-lines argument carries in place of its\n * `-`. It is a NUL, which no path and no option can hold, and it never\n * reaches a message: a page read from stdin is labelled `<stdin>`.\n */\nexport const STDIN_LINES_MARKER = \"\\u0000\";\n\n/** `-:9`, `-:14-18`: stdin, and the lines of it a command was pointed at. */\nconst STDIN_WITH_LINES = /^-(:[1-9][0-9]*(?:-[1-9][0-9]*)?)$/;\n\n/**\n * Rewrite `-:L` so commander reads it as an operand.\n *\n * `-` is stdin in every command of the family, so `-:9` is stdin and a line\n * range, the form `cite add` takes its claim's lines in. Commander tells an\n * option from an operand lexically, by the leading `-`, and would reject the\n * token as an unknown option before any command saw it. The rewrite is here,\n * once, rather than in the one command that reads the form today: the rule\n * is about what `-` means to the family, not about that command.\n */\nexport function normalizeStdinArgv(argv: readonly string[]): string[] {\n  return argv.map((arg) => {\n    const lines = STDIN_WITH_LINES.exec(arg)?.[1];\n    return lines === undefined ? arg : `${STDIN_LINES_MARKER}${lines}`;\n  });\n}\n\nexport async function runProgram(\n  program: Command,\n  argv: string[] = process.argv,\n): Promise<void> {\n  setProgramName(program.name());\n  try {\n    await program.parseAsync(normalizeStdinArgv(argv));\n  } catch (err) {\n    // `exitOverride()` makes commander throw on every terminating condition,\n    // including the successful ones. Branch on `err.exitCode`, not on a list of\n    // code strings: `--help` is `commander.helpDisplayed`, `-V` is\n    // `commander.version`, and `help get` is a third code, `commander.help` —\n    // all carrying exitCode 0, and a hand-written list would eventually miss\n    // one and turn a success into a usage error.\n    if (err instanceof CommanderError) {\n      // Say nothing. `Command.error()` has already written the message and the\n      // after-error hint; `fail()` would add \"Unexpected error: …\" on top,\n      // because a CommanderError is not a ToolError.\n      //\n      // `process.exitCode`, not `process.exit()`: Node does not flush queued\n      // async stderr writes on `process.exit`, which truncates the very message\n      // the user needs.\n      process.exitCode = err.exitCode === 0 ? 0 : 2;\n      return;\n    }\n    throw err;\n  }\n}\n\n/**\n * Whether `moduleUrl` is the file Node was asked to run.\n *\n * Pass the entry file's own `import.meta.url`. After bundling, shared code\n * lands in a chunk whose URL is never argv[1], so this cannot read\n * `import.meta.url` itself.\n */\nexport function isMainModule(moduleUrl: string): boolean {\n  const entry = process.argv[1];\n  if (!entry) return false;\n  try {\n    return realpathSync(entry) === fileURLToPath(moduleUrl);\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Treat a closed reader on stdout or stderr as the end of output.\n *\n * `manni cite check | head -1` closes the pipe while the command is still\n * writing, and the next write fails with EPIPE. Node emits that as an `error`\n * event on the stream, and with no listener it is thrown as an uncaught\n * exception: a stack trace and exit 1 from a command that did nothing wrong.\n *\n * The listener swallows EPIPE and nothing else, so any other stream error\n * still surfaces the way it did. The command then runs to completion and exits\n * with its own code rather than a fixed 0: `set -o pipefail; manni meta\n * validate | head` must still fail when validation does. Writes after the\n * pipe closed go nowhere, which is what the reader asked for.\n */\nexport function endOutputOnClosedReader(\n  streams: readonly NodeJS.EventEmitter[] = [process.stdout, process.stderr],\n): void {\n  for (const stream of streams) {\n    stream.on(\"error\", (err: NodeJS.ErrnoException) => {\n      if (err.code === \"EPIPE\") return;\n      throw err;\n    });\n  }\n}\n\n/** Run `build()` as a bin when `moduleUrl` is the entry, and not when imported. */\nexport function runIfMain(\n  moduleUrl: string,\n  build: () => Command | Promise<Command>,\n): void {\n  if (!isMainModule(moduleUrl)) return;\n  endOutputOnClosedReader();\n  Promise.resolve(build()).then(runProgram).catch(fail);\n}\n"],"mappings":";;;;;;;;;;;AASA,SAAS,oBAAoB;AAC7B,SAAS,qBAAqB;AAC9B,SAAS,sBAAoC;AAYtC,SAAS,KAAK,KAAqB;AACxC,QAAM,MACJ,eAAe,YACX,IAAI,UACJ,qBAAqB,aAAa,GAAG,CAAC;AAC5C,QAAM,SAAS,YAAY;AAK3B,aAAW,QAAQ,IAAI,QAAQ,QAAQ,EAAE,EAAE,MAAM,IAAI,GAAG;AACtD,YAAQ,OAAO,MAAM,GAAG,MAAM,KAAK,IAAI;AAAA,CAAI;AAAA,EAC7C;AACA,UAAQ,KAAK,CAAC;AAChB;AAOO,IAAM,qBAAqB;AAGlC,IAAM,mBAAmB;AAYlB,SAAS,mBAAmB,MAAmC;AACpE,SAAO,KAAK,IAAI,CAAC,QAAQ;AACvB,UAAM,QAAQ,iBAAiB,KAAK,GAAG,IAAI,CAAC;AAC5C,WAAO,UAAU,SAAY,MAAM,GAAG,kBAAkB,GAAG,KAAK;AAAA,EAClE,CAAC;AACH;AAEA,eAAsB,WACpB,SACA,OAAiB,QAAQ,MACV;AACf,iBAAe,QAAQ,KAAK,CAAC;AAC7B,MAAI;AACF,UAAM,QAAQ,WAAW,mBAAmB,IAAI,CAAC;AAAA,EACnD,SAAS,KAAK;AAOZ,QAAI,eAAe,gBAAgB;AAQjC,cAAQ,WAAW,IAAI,aAAa,IAAI,IAAI;AAC5C;AAAA,IACF;AACA,UAAM;AAAA,EACR;AACF;AASO,SAAS,aAAa,WAA4B;AACvD,QAAM,QAAQ,QAAQ,KAAK,CAAC;AAC5B,MAAI,CAAC,MAAO,QAAO;AACnB,MAAI;AACF,WAAO,aAAa,KAAK,MAAM,cAAc,SAAS;AAAA,EACxD,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AAgBO,SAAS,wBACd,UAA0C,CAAC,QAAQ,QAAQ,QAAQ,MAAM,GACnE;AACN,aAAW,UAAU,SAAS;AAC5B,WAAO,GAAG,SAAS,CAAC,QAA+B;AACjD,UAAI,IAAI,SAAS,QAAS;AAC1B,YAAM;AAAA,IACR,CAAC;AAAA,EACH;AACF;AAGO,SAAS,UACd,WACA,OACM;AACN,MAAI,CAAC,aAAa,SAAS,EAAG;AAC9B,0BAAwB;AACxB,UAAQ,QAAQ,MAAM,CAAC,EAAE,KAAK,UAAU,EAAE,MAAM,IAAI;AACtD;","names":[]}

package/dist/{chunk-G5CM2VGQ.js → chunk-YFQBFNQS.js}

@@ -1,7 +1,11 @@
 #!/usr/bin/env node
 import {
   discoverArtifacts
-} from "./chunk-5HNHEUD5.js";
+} from "./chunk-XYLUCIKQ.js";
+import {
+  parseHookPayload,
+  readStdin
+} from "./chunk-TZOYZK2E.js";
 import {
   MANIFEST_VERSION,
   hashFile,
@@ -11,10 +15,10 @@ import {
   relPosix,
   sha256Hex,
   writeManifest
-} from "./chunk-CFDUZRM2.js";
+} from "./chunk-7QMCHA4N.js";
 import {
   TracevalsError
-} from "./chunk-3R23C5DT.js";
+} from "./chunk-UKZNLVJW.js";
 
 // src/tracevals/commands/capture.ts
 import { resolve as resolve2 } from "node:path";
@@ -133,94 +137,6 @@ function git(args, cwd, timeoutMs = 5e3) {
   });
 }
 
-// src/tracevals/capture/hook.ts
-var REASON_KEYS = ["how", "why", "source", "reason"];
-function str(record, key) {
-  const value = record[key];
-  return typeof value === "string" && value.length > 0 ? value : void 0;
-}
-function parseHookPayload(raw) {
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch (err) {
-    throw new TracevalsError(
-      `hook payload is not JSON: ${err instanceof Error ? err.message : String(err)}`
-    );
-  }
-  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
-    throw new TracevalsError(
-      "hook payload must be a JSON object; Claude Code writes one object on stdin"
-    );
-  }
-  const record = parsed;
-  let reason;
-  for (const key of REASON_KEYS) {
-    reason = str(record, key);
-    if (reason !== void 0) break;
-  }
-  return {
-    ...str(record, "session_id") !== void 0 ? { sessionId: str(record, "session_id") } : {},
-    ...str(record, "transcript_path") !== void 0 ? { transcriptPath: str(record, "transcript_path") } : {},
-    ...str(record, "cwd") !== void 0 ? { cwd: str(record, "cwd") } : {},
-    ...str(record, "hook_event_name") !== void 0 ? { hookEvent: str(record, "hook_event_name") } : {},
-    ...reason !== void 0 ? { reason } : {}
-  };
-}
-function readStdin(stream = process.stdin, options = {}) {
-  const maxBytes = options.maxBytes ?? 1e6;
-  const timeoutMs = options.timeoutMs ?? 1500;
-  if (stream.isTTY) return Promise.resolve("");
-  return new Promise((settle, fail) => {
-    const chunks = [];
-    let total = 0;
-    let done = false;
-    const stop = () => {
-      clearTimeout(timer);
-      stream.off("data", onData);
-      stream.off("end", onEnd);
-      stream.off("error", onError);
-      stream.pause();
-    };
-    const finish = () => {
-      if (done) return;
-      done = true;
-      stop();
-      settle(Buffer.concat(chunks).toString("utf-8"));
-    };
-    const abort = (err) => {
-      if (done) return;
-      done = true;
-      stop();
-      fail(err);
-    };
-    const onData = (chunk) => {
-      const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-      total += buf.length;
-      if (total > maxBytes) {
-        abort(
-          new TracevalsError(
-            `hook payload exceeded ${maxBytes} bytes; this is not a Claude Code hook envelope`
-          )
-        );
-        return;
-      }
-      chunks.push(buf);
-    };
-    const onEnd = () => {
-      finish();
-    };
-    const onError = () => {
-      finish();
-    };
-    const timer = setTimeout(finish, timeoutMs);
-    stream.on("data", onData);
-    stream.on("end", onEnd);
-    stream.on("error", onError);
-    stream.resume();
-  });
-}
-
 // src/tracevals/commands/capture.ts
 async function runCapture(options = {}) {
   const raw = options.stdin ?? await readStdin();
@@ -289,9 +205,7 @@ export {
   deviceId,
   redactDeep,
   readGit,
-  parseHookPayload,
-  readStdin,
   runCapture,
   renderCapture
 };
-//# sourceMappingURL=chunk-G5CM2VGQ.js.map
+//# sourceMappingURL=chunk-YFQBFNQS.js.map

package/dist/chunk-YFQBFNQS.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/tracevals/commands/capture.ts","../src/tracevals/capture/build.ts"],"sourcesContent":["/**\n * `manni tracevals capture` — record what the project's instruction artifacts\n * said, and at which commit, at the moment a session started (ADR 01024).\n *\n * **This is the one write path `run` never takes.** CLAUDE.md states that\n * evaluation is read-only, so the manifest is written by a separate,\n * explicitly-invoked command — the same shape as `fill`. `run` only ever reads\n * a manifest, and degrades cleanly when there is none.\n *\n * Designed to be wired to a `SessionStart` hook, which constrains it in two\n * ways that are not obvious:\n *\n *  - **Nothing goes to stdout in hook mode.** Claude Code adds a\n *    SessionStart hook's stdout to the model's context, so a report printed\n *    there would be a side effect on the very session being observed. In hook\n *    mode the report goes to stderr, where an exit-0 hook's output is a debug\n *    line and nothing more.\n *  - **The transcript is never read.** `transcript_path` is recorded as a\n *    correlation key only. At SessionStart the file barely exists, and the\n *    reference warns that it lags the conversation in any case.\n */\nimport { resolve } from \"node:path\";\nimport { loadConfig } from \"../core/config.js\";\nimport { buildManifest } from \"../capture/build.js\";\nimport { manifestPathFor, writeManifest } from \"../capture/manifest.js\";\nimport type { SessionManifest } from \"../capture/types.js\";\nimport { parseHookPayload, readStdin } from \"../capture/hook.js\";\nimport type { SummaryFormat } from \"../reporters/index.js\";\nimport { TracevalsError } from \"../types.js\";\n\nexport interface CaptureCommandOptions {\n  /**\n   * The hook payload. Undefined means \"read stdin\"; an empty string means\n   * \"there was none\", which is the hand-run path.\n   */\n  stdin?: string;\n  /** Overrides the payload's `cwd` as the project root to scan. */\n  project?: string;\n  /** Overrides the payload's `session_id`. */\n  sessionId?: string;\n  /** Write here instead of `<project>/<capture.dir>/<session-id>.json`. */\n  out?: string;\n  /** Directory holding manni.config.yaml; defaults to the project root. */\n  configDir?: string;\n  /** `-c/--config`: read this file instead of discovering one. */\n  config?: string;\n  /** `--no-config`: skip discovery and run on the built-in defaults. */\n  noConfig?: boolean;\n  format?: SummaryFormat;\n  /**\n   * Version recorded in the manifest. Passed in rather than read from\n   * package.json here: this module is bundled into an unpredictable chunk\n   * path, so any relative require of it resolves differently in dist than in\n   * src. The CLI, which is not bundled away, supplies it.\n   */\n  version?: string;\n}\n\nexport interface CaptureCommandResult {\n  manifest: SessionManifest;\n  /** Where the manifest was written. */\n  path: string;\n  /** The report, wherever it is destined for. */\n  rendered: string;\n  /** What the caller should print to stdout — empty in hook mode. */\n  stdout: string;\n  /** What the caller should print to stderr — the report, in hook mode. */\n  stderr: string;\n  exitCode: number;\n}\n\nexport async function runCapture(\n  options: CaptureCommandOptions = {},\n): Promise<CaptureCommandResult> {\n  const raw = options.stdin ?? (await readStdin());\n  const hookMode = raw.trim().length > 0;\n  const payload = hookMode ? parseHookPayload(raw) : {};\n\n  const sessionId = options.sessionId ?? payload.sessionId;\n  if (sessionId === undefined) {\n    // Without an id the manifest has no name and no join key, and writing one\n    // under a guessed name would produce evidence nothing could ever find.\n    throw new TracevalsError(\n      \"no session id: pipe a Claude Code hook payload on stdin, or pass --session-id\",\n    );\n  }\n\n  const root = resolve(options.project ?? payload.cwd ?? process.cwd());\n  const config = await loadConfig(options.configDir ?? root, {\n    ...(options.config === undefined ? {} : { configPath: options.config }),\n    ...(options.noConfig === undefined ? {} : { noConfig: options.noConfig }),\n  });\n\n  const manifest = await buildManifest({\n    sessionId,\n    root,\n    hookEvent: payload.hookEvent ?? \"manual\",\n    ...(payload.reason !== undefined ? { reason: payload.reason } : {}),\n    ...(payload.transcriptPath !== undefined\n      ? { transcriptPath: payload.transcriptPath }\n      : {}),\n    config,\n    redact: config.judge.redact,\n    ...(options.version !== undefined ? { version: options.version } : {}),\n  });\n\n  const path =\n    options.out ??\n    manifestPathFor(resolve(root, config.capture.dir), sessionId);\n  try {\n    await writeManifest(path, manifest);\n  } catch (err) {\n    throw new TracevalsError(\n      `could not write ${path}: ${err instanceof Error ? err.message : String(err)}`,\n    );\n  }\n\n  const rendered =\n    options.format === \"json\"\n      ? JSON.stringify({ path, manifest }, null, 2)\n      : renderCapture(path, manifest);\n\n  return {\n    manifest,\n    path,\n    rendered,\n    // The whole point of the split: a SessionStart hook's stdout becomes model\n    // context, so hook mode writes none.\n    stdout: hookMode ? \"\" : rendered,\n    stderr: hookMode ? rendered : \"\",\n    exitCode: 0,\n  };\n}\n\nexport function renderCapture(\n  path: string,\n  manifest: SessionManifest,\n): string {\n  const lines = [\n    `Captured session ${manifest.sessionId}`,\n    `  manifest   ${path}`,\n    `  artifacts  ${manifest.artifacts.length} hashed`,\n  ];\n  if (manifest.git !== undefined) {\n    lines.push(\n      `  commit     ${manifest.git.sha}${manifest.git.branch ? ` (${manifest.git.branch})` : \"\"}${\n        manifest.git.dirty ? \" — working tree dirty\" : \"\"\n      }`,\n    );\n  } else {\n    lines.push(\"  commit     not a git repository, or git is unavailable\");\n  }\n  lines.push(`  device     ${manifest.device.id} (${manifest.device.platform})`);\n  return lines.join(\"\\n\");\n}\n","/**\n * Building a session manifest (ADR 01024) — the producing half.\n *\n * Separate from `capture/manifest.ts` because this side reaches for\n * `discoverArtifacts`, which imports `artifacts/resolve.ts`, which consumes a\n * manifest. Producing and consuming therefore cannot share a module.\n */\nimport { spawn } from \"node:child_process\";\nimport { hostname, platform, userInfo } from \"node:os\";\nimport { resolve } from \"node:path\";\nimport { discoverArtifacts } from \"../artifacts/discover.js\";\nimport { makeRedactor, type Redactor } from \"../judge/redact.js\";\nimport { hashFile, relPosix, sha256Hex } from \"./manifest.js\";\nimport {\n  MANIFEST_VERSION,\n  type ManifestArtifact,\n  type ManifestGit,\n  type SessionManifest,\n} from \"./types.js\";\n\nexport interface BuildManifestOptions {\n  sessionId: string;\n  /** Project root to scan, and the base every artifact path is relative to. */\n  root: string;\n  hookEvent?: string;\n  reason?: string;\n  transcriptPath?: string;\n  /** The resolved config section, recorded as provenance. */\n  config?: unknown;\n  /** `judge.redact` sources, applied to the manifest's free text (ADR 01020). */\n  redact?: readonly string[];\n  version?: string;\n  /** Test seam: `false` skips shelling out to git. */\n  git?: ManifestGit | false;\n}\n\n/**\n * Hash every instruction artifact the project holds, at the commit it holds\n * them at.\n *\n * The population is `discoverArtifacts`' — the same one `fill` authors against\n * — so capture and authoring never disagree about what an instruction artifact\n * is. That scope is **project-only** by its own design note, so a user-level or\n * plugin artifact is simply absent from the manifest, and its hash check at run\n * time degrades to the mtime heuristic rather than to a wrong answer.\n *\n * **Redaction covers the free text and never a join key.** `root`,\n * `transcriptPath`, `git.branch`, `reason` and the recorded `config` go through\n * the `judge.redact` redactor; `sessionId`, an artifact's `name` and `path`,\n * and every `sha256` do not. A redactor applied to a join key would turn an\n * exact check into a silent `skipped` — the one failure mode this whole feature\n * exists to remove — and those keys are the project's own vocabulary and its\n * repository-relative paths, not somewhere a credential lives. A secret in an\n * artifact path is a problem to fix in the path, the same call ADR 01020 makes\n * about a secret in a `SKILL.md`.\n */\nexport async function buildManifest(\n  options: BuildManifestOptions,\n): Promise<SessionManifest> {\n  const root = resolve(options.root);\n  const redact = makeRedactor(options.redact ?? []);\n\n  const discovered = await discoverArtifacts({ root });\n  const artifacts: ManifestArtifact[] = [];\n  for (const found of discovered.artifacts) {\n    const rel = relPosix(root, found.artifact.path);\n    if (rel === null) continue;\n    const digest = await hashFile(found.artifact.path);\n    // An artifact that cannot be read is one the manifest says nothing about,\n    // which degrades to the mtime heuristic at run time. Never a crash.\n    if (digest === null) continue;\n    artifacts.push({\n      name: found.artifact.name,\n      type: found.artifact.type,\n      path: rel,\n      sha256: digest,\n      bytes: Buffer.byteLength(found.artifact.content, \"utf-8\"),\n    });\n  }\n  // Stable order, so two captures of an unchanged tree produce the same bytes.\n  artifacts.sort((a, b) => (a.path < b.path ? -1 : a.path > b.path ? 1 : 0));\n\n  const git =\n    options.git === false ? undefined : (options.git ?? (await readGit(root)));\n\n  return {\n    version: MANIFEST_VERSION,\n    sessionId: options.sessionId,\n    capturedAt: new Date().toISOString(),\n    hookEvent: options.hookEvent ?? \"manual\",\n    ...(options.reason !== undefined ? { reason: redact(options.reason) } : {}),\n    ...(options.transcriptPath !== undefined\n      ? { transcriptPath: redact(options.transcriptPath) }\n      : {}),\n    root: redact(root),\n    ...(git !== undefined\n      ? {\n          git: {\n            sha: git.sha,\n            ...(git.branch !== undefined ? { branch: redact(git.branch) } : {}),\n            dirty: git.dirty,\n          },\n        }\n      : {}),\n    device: { id: deviceId(), platform: platform() },\n    tool: { name: \"manni-tracevals\", version: options.version ?? \"unknown\" },\n    artifacts,\n    config: redactDeep(options.config ?? {}, redact),\n  };\n}\n\n/**\n * A stable, opaque per-machine id. Not the hostname: \"was this captured here?\"\n * is the whole question, and answering it does not require shipping the name of\n * the machine into a file that travels with the repository.\n */\nexport function deviceId(): string {\n  let user = \"\";\n  try {\n    user = userInfo().username;\n  } catch {\n    // A container with no passwd entry throws; the digest is still stable.\n  }\n  return sha256Hex(`${hostname()} ${user} ${platform()}`).slice(0, 16);\n}\n\n/**\n * Redact every string in a JSON-shaped value. Used for the recorded config\n * only — never for a join key.\n */\nexport function redactDeep(value: unknown, redact: Redactor): unknown {\n  if (typeof value === \"string\") return redact(value);\n  if (Array.isArray(value)) return value.map((v) => redactDeep(v, redact));\n  if (value !== null && typeof value === \"object\") {\n    const out: Record<string, unknown> = {};\n    for (const [key, member] of Object.entries(value)) {\n      out[key] = redactDeep(member, redact);\n    }\n    return out;\n  }\n  return value;\n}\n\n/**\n * What `git` says about `root`, or nothing. Every failure mode — git absent,\n * not a repository, a timeout — degrades to an absent block, because a manifest\n * without a SHA is still a manifest with hashes in it.\n */\nexport async function readGit(root: string): Promise<ManifestGit | undefined> {\n  const sha = await git([\"rev-parse\", \"HEAD\"], root);\n  if (sha === null || !/^[0-9a-f]{40}$/.test(sha)) return undefined;\n  const branch = await git([\"rev-parse\", \"--abbrev-ref\", \"HEAD\"], root);\n  const status = await git(\n    [\"status\", \"--porcelain\", \"--untracked-files=no\"],\n    root,\n  );\n  return {\n    sha,\n    // Detached HEAD reports the literal \"HEAD\", which is not a branch name.\n    ...(branch !== null && branch !== \"HEAD\" ? { branch } : {}),\n    dirty: status !== null && status.length > 0,\n  };\n}\n\n/** One `git` invocation, argv-only and bounded — the shape ADR 01011 uses. */\nfunction git(\n  args: string[],\n  cwd: string,\n  timeoutMs = 5000,\n): Promise<string | null> {\n  return new Promise((settle) => {\n    let done = false;\n    let child;\n    try {\n      // shell:false — nothing here is ever parsed as shell syntax.\n      child = spawn(\"git\", args, { cwd, shell: false, windowsHide: true });\n    } catch {\n      settle(null);\n      return;\n    }\n    // `finish` is declared below the timer because it clears it; the timer\n    // callback only runs after both exist.\n    const timer = setTimeout(() => {\n      child.kill();\n      finish(null);\n    }, timeoutMs);\n    const finish = (value: string | null): void => {\n      if (done) return;\n      done = true;\n      clearTimeout(timer);\n      settle(value);\n    };\n    let out = \"\";\n    child.stdout.on(\"data\", (d: Buffer) => {\n      out += d.toString(\"utf-8\");\n    });\n    child.stderr.resume();\n    child.on(\"error\", () => { finish(null); });\n    child.on(\"close\", (code) => { finish(code === 0 ? out.trim() : null); });\n  });\n}\n"],"mappings":"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","names":["resolve","git","resolve"]}