create-pathfinder 4.0.0 → 4.2.0

package/src/cli.mjs

@@ -7,7 +7,14 @@
  */
 
 import { findKitRoot, COPY_LIST, VERSION } from "./kit.mjs";
-import { applyAdapterPlan, applyPlan, planAdapters, planInstall } from "./install.mjs";
+import {
+  applyAdapterPlan,
+  applyHookPlan,
+  applyPlan,
+  planAdapters,
+  planHooks,
+  planInstall,
+} from "./install.mjs";
 import { detect, detectedToolLabels } from "./detect.mjs";
 import { initRepository } from "./git.mjs";
 import { nonInteractivePrompter } from "./prompt.mjs";
@@ -17,6 +24,7 @@ import { kickstartPrompt, kickstartPromptLines } from "./kickstart-prompt.mjs";
 import { createTheme } from "./theme.mjs";
 import { createProgress } from "./progress.mjs";
 import { summarize } from "./outcome.mjs";
+import { activationLines } from "./activation.mjs";
 import {
   HARNESSES,
   HARNESS_IDS,
@@ -239,12 +247,20 @@ export async function run(
       ? planAdapters(harnesses, { kitRoot, targetRoot: cwd, force: options.force })
       : [];
 
+  // Planned here for the same reasons, and safe for one more: a handler lives
+  // under a harness's hooks directory, which no copy-list entry writes to
+  // either. A harness with no session lifecycle event contributes nothing, so
+  // this is empty for every destination but Claude Code — and empty is the
+  // whole of what a Codex destination receives.
+  const hookPlan =
+    harnesses.length > 0 ? planHooks(harnesses, { targetRoot: cwd, force: options.force }) : [];
+
   // Zero on a dry run, which disables the bar. A dry run carries nothing out,
   // and a bar filling for work that is not happening would be the exact species
   // of theatre this treatment was designed to avoid.
   const progress = createProgress({
     theme,
-    total: options.dryRun ? 0 : plan.length + adapterPlan.length,
+    total: options.dryRun ? 0 : plan.length + adapterPlan.length + hookPlan.length,
     out,
   });
 
@@ -286,6 +302,14 @@ export async function run(
       ),
   });
 
+  const hooks = generateHooks({
+    plan: hookPlan,
+    harnesses,
+    options,
+    result,
+    onProgress: (unit) => progress.advance(unit),
+  });
+
   progress.finish();
   if (!options.dryRun && theme.tier !== "contract") out("\n");
 
@@ -293,7 +317,7 @@ export async function run(
   // plan or a result: the two renderings disagree about everything except the
   // facts, and this is what makes "except the facts" true rather than a hope
   // about two functions being edited together.
-  const outcome = summarize({ plan, result, adapters, harnesses, options });
+  const outcome = summarize({ plan, result, adapters, hooks, harnesses, options });
 
   report({ outcome, harnesses, customTools, cwd, gitRoot, options, out, err, theme });
 
@@ -515,6 +539,35 @@ function generateAdapters({ plan, harnesses, options, result, onProgress, onHarn
   return { plan, result: applied, blocked: false };
 }
 
+/**
+ * Generate the session hook handlers for the selected harnesses.
+ *
+ * Returns the plan and the result together, exactly as `generateAdapters`
+ * does, so the report can tell "no harness has a handler" from "a handler was
+ * planned and produced nothing".
+ *
+ * No per-harness milestone. A handler is one file, and a milestone line
+ * announcing it would give a single inert file the same weight as the
+ * twenty-two adapters above it. The summary states it once, where the reader
+ * can act on it.
+ *
+ * Blocked by a failed copy for the same reason adapters are: the handler reads
+ * `context/` to orient a session, and putting one down beside a copy that did
+ * not finish would generate a file whose whole subject may be missing.
+ */
+function generateHooks({ plan, harnesses, options, result, onProgress }) {
+  const none = { plan: [], result: applyHookPlan([]), blocked: false };
+
+  if (harnesses.length === 0 || plan.length === 0) return none;
+  if (result.errors.length > 0) return { ...none, blocked: true };
+
+  return {
+    plan,
+    result: applyHookPlan(plan, { dryRun: options.dryRun, onProgress }),
+    blocked: false,
+  };
+}
+
 /**
  * The one line under the closing headline: what this run actually did.
  *
@@ -1261,7 +1314,7 @@ function contractAdapterLines({ outcome, options, theme }) {
 
   const lines = [];
 
-  for (const { harness, generated, replaced, unchanged, conflicts, orphans } of outcome.harnessRows) {
+  for (const { harness, generated, replaced, unchanged, conflicts, orphans, handlers } of outcome.harnessRows) {
     lines.push(
       `  ${generated} ${harness.label} skill adapter${plural(generated)} ` +
         (options.dryRun ? "to generate" : "generated"),
@@ -1294,6 +1347,105 @@ function contractAdapterLines({ outcome, options, theme }) {
       lines.push(`  ${path} delegates to a skill this version no longer`);
       lines.push("  ships. It was left in place; delete it yourself if you want it gone.");
     }
+
+    lines.push(...contractHandlerLines({ harness, handlers, options }));
+  }
+
+  return lines;
+}
+
+/**
+ * The hook handler half, for a harness that has one.
+ *
+ * Silent when nothing was generated and nothing needs a human, which is every
+ * harness with no session lifecycle event. A tool that has no handlers should
+ * print no sentence about handlers.
+ *
+ * The inert clause is the one thing this must say. A file appearing under
+ * `.claude/hooks/` looks like something that runs, and it does not: Pathfinder
+ * writes no settings file, so nothing references it until a human says so.
+ */
+function contractHandlerLines({ harness, handlers, options }) {
+  const { generated, replaced, unchanged, conflicts, orphans } = handlers;
+  const lines = [];
+
+  if (generated > 0) {
+    lines.push(
+      `  ${generated} ${harness.label} session hook handler${plural(generated)} ` +
+        (options.dryRun ? "to generate" : "generated") +
+        " (inert; nothing runs it yet)",
+    );
+  }
+
+  if (replaced > 0) {
+    lines.push(`  ${replaced} ${harness.label} session hook handler${plural(replaced)} replaced (--force)`);
+  }
+
+  if (unchanged > 0) {
+    lines.push(`  ${unchanged} ${harness.label} session hook handler${plural(unchanged)} already up to date`);
+  }
+
+  for (const path of conflicts) {
+    lines.push(`  ${path} was left untouched because Pathfinder`);
+    lines.push("  did not write it. Re-run with --force to replace it.");
+  }
+
+  for (const path of orphans) {
+    lines.push(`  ${path} is a handler this version no longer`);
+    lines.push("  ships. It was left in place; delete it yourself if you want it gone.");
+  }
+
+  return lines;
+}
+
+/**
+ * The harnesses whose handler this run put on disk, or would.
+ *
+ * Generated, replaced, or already up to date — all three mean the file is
+ * there, or will be, and the fragment below is worth pasting. Under
+ * `--dry-run` none of it has happened yet, which is what the note's tense is
+ * for rather than a second membership rule here. A conflict deliberately does
+ * not count: that path holds a file Pathfinder did not write, so telling
+ * someone to activate "the handler" would point their settings at a stranger's
+ * script.
+ */
+function activatable(outcome) {
+  if (outcome.blocked) return [];
+  return outcome.harnessRows
+    .filter(({ handlers }) => handlers.generated + handlers.replaced + handlers.unchanged > 0)
+    .map(({ harness }) => harness);
+}
+
+/**
+ * The activation note, as a block in the expressive rendering.
+ *
+ * This rendering, and only this one. `contractReport` is a promise kept to
+ * scripts written against 1.4.1 and every byte of it is pinned; a multi-line
+ * JSON fragment appended to that output is a new fact in the middle of a
+ * stream somebody is parsing, and no amount of usefulness makes that a safe
+ * place to put it. A person at a terminal reads the note here; everyone else
+ * reads the guide, which is checked against this same text by the validator.
+ *
+ * A heading and a payload, like `warnBlock`, and pointedly not one: nothing
+ * here went wrong, and a warning glyph over an optional capability is how a
+ * tool teaches people to ignore its warnings. The fragment stays undecorated
+ * for the reason the warning blocks keep their paths undecorated — selecting
+ * it in a terminal must copy characters, not escapes.
+ *
+ * `--dry-run` gets the same block in the future tense. The handler it names
+ * has not been written, and telling somebody to activate a file that is not
+ * there is exactly the kind of confident narration a dry run exists to avoid.
+ */
+function expressiveActivationBlock({ outcome, options, theme }) {
+  const lines = [];
+
+  for (const harness of activatable(outcome)) {
+    lines.push("");
+    lines.push(`  ${theme.glyph.info}  ${theme.bold(`${harness.label} session orientation is optional`)}`);
+    lines.push("");
+    for (const line of activationLines(harness, { dryRun: options.dryRun })) {
+      lines.push(line === "" ? "" : `     ${line}`);
+    }
   }
 
   return lines;
@@ -1422,6 +1574,7 @@ function expressiveReport({ outcome, harnesses, customTools, cwd, gitRoot, optio
   }
 
   lines.push(...expressiveAdapterBlocks({ outcome, theme }));
+  lines.push(...expressiveActivationBlock({ outcome, options, theme }));
 
   if (customTools.length > 0) lines.push(...customToolLines(customTools));
 
@@ -1524,7 +1677,7 @@ function expressiveAdapterLines({ outcome, options, theme }) {
 
   const lines = [];
 
-  for (const { harness, generated, replaced, unchanged, conflicts, orphans } of outcome.harnessRows) {
+  for (const { harness, generated, replaced, unchanged, conflicts, orphans, handlers } of outcome.harnessRows) {
     lines.push(
       railed(
         theme,
@@ -1566,6 +1719,74 @@ function expressiveAdapterLines({ outcome, options, theme }) {
         ),
       );
     }
+
+    lines.push(...expressiveHandlerLines({ harness, handlers, options, theme }));
+  }
+
+  return lines;
+}
+
+/**
+ * The hook handler counts for one harness, on the gutter.
+ *
+ * Nothing at all for a harness with no handlers. The inert clause rides the
+ * generated line rather than a line of its own, because it is not news — it is
+ * what the file *is*, and a separate line would read as a warning about
+ * something going wrong.
+ */
+function expressiveHandlerLines({ harness, handlers, options, theme }) {
+  const mark = theme.glyph;
+  const { generated, replaced, unchanged, conflicts, orphans } = handlers;
+  const lines = [];
+
+  if (generated > 0) {
+    lines.push(
+      railed(
+        theme,
+        theme.ok(
+          `${mark.ok} ${generated} ${harness.label} session hook handler${plural(generated)} ` +
+            (options.dryRun ? "to generate" : "generated"),
+        ) + theme.dim(" (inert; nothing runs it yet)"),
+      ),
+    );
+  }
+
+  if (replaced > 0) {
+    lines.push(
+      railed(
+        theme,
+        theme.info(`${mark.info} ${replaced} ${harness.label} session hook handler${plural(replaced)} replaced (--force)`),
+      ),
+    );
+  }
+
+  if (unchanged > 0) {
+    lines.push(
+      railed(
+        theme,
+        theme.dim(`${mark.info} ${unchanged} ${harness.label} session hook handler${plural(unchanged)} already up to date`),
+      ),
+    );
+  }
+
+  if (conflicts.length > 0) {
+    lines.push(
+      railed(
+        theme,
+        theme.warn(`${mark.warn} ${conflicts.length} ${harness.label} hook file${plural(conflicts.length)} left untouched`) +
+          theme.dim(conflicts.length === 1 ? " (Pathfinder did not write it)" : " (Pathfinder did not write them)"),
+      ),
+    );
+  }
+
+  if (orphans.length > 0) {
+    lines.push(
+      railed(
+        theme,
+        theme.warn(`${mark.warn} ${orphans.length} ${harness.label} orphan hook handler${plural(orphans.length)}`) +
+          theme.dim(" (this version no longer ships it)"),
+      ),
+    );
   }
 
   return lines;
@@ -1577,7 +1798,7 @@ function expressiveAdapterBlocks({ outcome, theme }) {
 
   const blocks = [];
 
-  for (const { harness, conflicts, orphans } of outcome.harnessRows) {
+  for (const { harness, conflicts, orphans, handlers } of outcome.harnessRows) {
     if (conflicts.length > 0) {
       const one = conflicts.length === 1;
       blocks.push(
@@ -1608,6 +1829,39 @@ function expressiveAdapterBlocks({ outcome, theme }) {
         }),
       );
     }
+
+    if (handlers.conflicts.length > 0) {
+      const one = handlers.conflicts.length === 1;
+      blocks.push(
+        ...warnBlock({
+          theme,
+          word: "Conflict",
+          summary: `${handlers.conflicts.length} ${harness.label} file${plural(handlers.conflicts.length)} at ${one ? "a path a session hook handler wants" : "paths session hook handlers want"}, which Pathfinder did not write`,
+          paths: handlers.conflicts,
+          advice: [
+            `Re-run with --force to replace ${one ? "it" : "them"} ${theme.glyph.dash} note that --force also`,
+            "overwrites Pathfinder kit files you have edited.",
+          ],
+        }),
+      );
+    }
+
+    if (handlers.orphans.length > 0) {
+      const one = handlers.orphans.length === 1;
+      blocks.push(
+        ...warnBlock({
+          theme,
+          word: "Orphan",
+          summary: `${handlers.orphans.length} ${harness.label} session hook handler${plural(handlers.orphans.length)} this version no longer ships`,
+          paths: handlers.orphans,
+          advice: [
+            `Left in place, deliberately: if you activated ${one ? "it" : "them"} by hand, removing`,
+            `${one ? "it" : "them"} would break that. Delete ${one ? "it" : "them"} yourself, and the hook`,
+            "configuration pointing at it, whenever you like.",
+          ],
+        }),
+      );
+    }
   }
 
   return blocks;

package/src/harnesses/adapter.mjs

@@ -71,6 +71,41 @@ export const ADAPTER_STATE = Object.freeze({
 /** States Pathfinder may write without `--force`. */
 const OWNED_STATES = new Set([ADAPTER_STATE.ABSENT, ADAPTER_STATE.STALE, ADAPTER_STATE.CURRENT]);
 
+/**
+ * The state table above, as a function, for every generated artifact.
+ *
+ * Deliberately knows nothing about adapters, skills, markers, or comment
+ * syntax. It takes the two facts a caller has already established — does this
+ * file carry a marker *this build owns*, and does this version still ship the
+ * thing at this path — plus the bytes, and returns which of the six states
+ * that is. `classifyAdapter` below is the skill-adapter spelling of it, and a
+ * generated hook handler is another; both get one table rather than two that
+ * drift.
+ *
+ * Ownership is the caller's to decide because the marker is where artifacts
+ * genuinely differ: an adapter is Markdown and carries an HTML comment, a
+ * handler is a script and carries a line comment, and each owns its own format
+ * version. Nothing else about the decision changes.
+ *
+ * @param {{existing: string|null, expected?: string|null,
+ *          ours?: boolean, shipped?: boolean}} input
+ * @returns {string} one of ADAPTER_STATE
+ */
+export function classifyOwnership({ existing = null, expected = null, ours = false, shipped = true }) {
+  // A marked file naming something this version does not ship. Reported so it
+  // cannot rot unnoticed, and left alone: deleting in someone else's
+  // repository is a different authority than writing, and is not claimed.
+  if (!shipped) return ours ? ADAPTER_STATE.ORPHAN : ADAPTER_STATE.UNMANAGED;
+  if (existing === null) return ADAPTER_STATE.ABSENT;
+  if (!ours) return ADAPTER_STATE.CONFLICT;
+  return existing === expected ? ADAPTER_STATE.CURRENT : ADAPTER_STATE.STALE;
+}
+
+/** May Pathfinder write this state without `--force`? */
+export function isOwnedState(state) {
+  return OWNED_STATES.has(state);
+}
+
 /**
  * Where a canonical skill lives, relative to the project root.
  *
@@ -251,23 +286,19 @@ export function isPathfinderAdapter(content) {
  */
 export function classifyAdapter({ name, isCanonicalSkill, existing = null, expected = null }) {
   const marker = readMarker(existing);
-  const ours = marker?.version === MARKER_VERSION;
 
-  const state = (() => {
-    // A marked file naming a skill this version does not ship. Reported so it
-    // cannot rot unnoticed, and left alone: deleting in someone else's
-    // repository is a different authority than writing, and is not claimed.
-    if (!isCanonicalSkill) return ours ? ADAPTER_STATE.ORPHAN : ADAPTER_STATE.UNMANAGED;
-    if (existing === null) return ADAPTER_STATE.ABSENT;
-    if (!ours) return ADAPTER_STATE.CONFLICT;
-    return existing === expected ? ADAPTER_STATE.CURRENT : ADAPTER_STATE.STALE;
-  })();
+  const state = classifyOwnership({
+    existing,
+    expected,
+    ours: marker?.version === MARKER_VERSION,
+    shipped: isCanonicalSkill,
+  });
 
   return {
     name,
     state,
     marker,
-    owned: OWNED_STATES.has(state),
+    owned: isOwnedState(state),
     forceReplaceable: state === ADAPTER_STATE.CONFLICT,
   };
 }

package/src/harnesses/hook.mjs

@@ -0,0 +1,142 @@
+/**
+ * Hook handlers: what they are, and which ones Pathfinder is allowed to write.
+ *
+ * A harness may expose a session lifecycle event. Where one does, Pathfinder
+ * can put a handler on disk for it — and that is the whole of what Pathfinder
+ * owns. It writes no settings file, registers nothing, and activates nothing:
+ * a generated handler is inert until a human adds native configuration
+ * pointing at it. That is why this module has no notion of a settings file, a
+ * hook registry, an event schema, or a cross-harness runtime, and must not
+ * grow one.
+ *
+ * Two differences from `adapter.mjs`, and only two:
+ *
+ * **There is no renderer.** An adapter is *rendered* from canonical
+ * frontmatter, which is what makes it body-independent and safe to commit. A
+ * handler's bytes *are* its behavior, so the canonical file beside this one is
+ * shipped verbatim. "Generation" here is a byte-for-byte copy of a file this
+ * package carries, which is also what makes the installed handler mechanically
+ * comparable to the canonical implementation.
+ *
+ * **The marker is a line comment.** The adapter marker is written for Markdown
+ * and spelled as an HTML comment; a script needs its own syntax and its own
+ * format version. Ownership is otherwise the identical discipline, decided by
+ * `classifyOwnership`, which both artifacts share.
+ *
+ * Nothing here deletes.
+ */
+
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+
+import { classifyOwnership, isOwnedState } from "./adapter.mjs";
+
+/** The marker token, and the format version this build writes and owns. */
+export const HOOK_MARKER_TOKEN = "pathfinder:hook";
+export const HOOK_MARKER_VERSION = 1;
+
+/**
+ * The marker line, parsed strictly.
+ *
+ * The version is captured rather than matched, for the same reason it is in
+ * `adapter.mjs`: a file written by a future format is recognized but not
+ * claimed. This build owns v1 and nothing else.
+ */
+const HOOK_MARKER_PATTERN = new RegExp(
+  `^//\\s*${HOOK_MARKER_TOKEN} v(\\d+)(?:\\s+name=(\\S+))?\\s*$`,
+);
+
+/**
+ * The marker a file carries, or null.
+ *
+ * Searched line by line rather than with a multiline regex so a marker quoted
+ * inside a string or a longer line cannot be mistaken for the real one.
+ *
+ * @returns {{version: number, name: string|null}|null}
+ */
+export function readHookMarker(content) {
+  if (typeof content !== "string") return null;
+
+  for (const line of content.split(/\r?\n/)) {
+    const match = HOOK_MARKER_PATTERN.exec(line.trim());
+    if (match) return { version: Number(match[1]), name: match[2] ?? null };
+  }
+
+  return null;
+}
+
+/** Does this file carry a marker in the format this build owns? */
+export function isPathfinderHook(content) {
+  return readHookMarker(content)?.version === HOOK_MARKER_VERSION;
+}
+
+/**
+ * The handlers a harness receives, in registry order.
+ *
+ * A harness with no `hooks` field receives none — which is every harness but
+ * Claude Code today, and is why a Codex destination gets no `.claude` artifact
+ * of any kind rather than a substitute for one.
+ */
+export function hooksFor(harness) {
+  return harness?.hooks ?? [];
+}
+
+/**
+ * The file names this version ships into one harness's hooks directory.
+ *
+ * Read from the registry rather than from the destination, for the reason
+ * `readCanonicalSkills` reads the kit: a stale file left behind in someone's
+ * project must not be able to add itself to the set Pathfinder claims to own,
+ * and this is what makes an orphan detectable at all.
+ */
+export function shippedHookFiles(harness) {
+  return new Set(hooksFor(harness).map((hook) => hook.file));
+}
+
+/** Where a harness looks for this handler, relative to the project root. */
+export function hookPath(harness, hook) {
+  return `${harness.hooksDir}/${hook.file}`;
+}
+
+/**
+ * The canonical bytes of one handler, exactly as they will be installed.
+ *
+ * Resolved against this module rather than against the kit root, because the
+ * handler is part of the *installer* — it ships inside the npm package under
+ * `src/`, and never through `copy-list.json`, which is uniform and would hand
+ * a Claude Code handler to every destination regardless of harness.
+ *
+ * Read on demand rather than cached: an install reads it once, and a stale
+ * module-level copy is a worse failure than a second `readFileSync`.
+ */
+export function readHookSource(hook) {
+  return readFileSync(hookSourcePath(hook), "utf8");
+}
+
+/** Where the canonical handler lives inside this package. Absolute. */
+export function hookSourcePath(hook) {
+  return fileURLToPath(new URL(`../hooks/${hook.name}.mjs`, import.meta.url));
+}
+
+/**
+ * Decide what Pathfinder may do with one path a handler would occupy.
+ *
+ * Takes the file's current contents rather than a path, so the decision is a
+ * pure function of what is on disk and can be tested exhaustively without one.
+ * `existing` is null when nothing is there.
+ *
+ * @param {{name: string, isShippedHook?: boolean,
+ *          existing: string|null, expected?: string|null}} input
+ */
+export function classifyHook({ name, isShippedHook = true, existing = null, expected = null }) {
+  const marker = readHookMarker(existing);
+
+  const state = classifyOwnership({
+    existing,
+    expected,
+    ours: marker?.version === HOOK_MARKER_VERSION,
+    shipped: isShippedHook,
+  });
+
+  return { name, state, marker, owned: isOwnedState(state) };
+}

package/src/harnesses/index.mjs

@@ -2,10 +2,12 @@
  * The harness registry.
  *
  * A harness is a coding tool that discovers skills by reading files from a
- * fixed directory in the project. This table says where each one looks and how
- * a user invokes what it finds there — nothing more. It is a table, not a
- * plugin system: a new harness is one object, and there is deliberately no
- * loader, no manifest format, and no way for a user to register their own.
+ * fixed directory in the project. This table says where each one looks, how a
+ * user invokes what it finds there, and — where the tool has a session
+ * lifecycle event — which handler files Pathfinder generates for it. Nothing
+ * more: it is a table, not a plugin system. A new harness is one object, and
+ * there is deliberately no loader, no manifest format, and no way for a user
+ * to register their own.
  *
  * Two entries today, and the second one cost exactly what this shape promised:
  * one object. Adding Codex changed no renderer, no ownership rule, no planner,
@@ -30,9 +32,22 @@
  * - `invocation` is how a user calls the skill once the harness has found it.
  *   Reporting only; nothing branches on it.
  *
+ * - `hooksDir` and `hooks` are optional and describe session lifecycle
+ *   handlers this harness can run. A harness that omits them receives no
+ *   handler and no substitute for one — which is the honest answer for a tool
+ *   with no lifecycle primitive, not a gap to fill. `name` names the canonical
+ *   handler in `src/hooks/<name>.mjs`; `file` is its destination name, stable
+ *   so a human who activated it once keeps a valid activation across updates
+ *   with no settings rewrite.
+ *
+ *   Pathfinder owns the handler file and nothing else. It writes no settings
+ *   file, so a generated handler is inert until a human activates it.
+ *
  * @type {ReadonlyArray<{id: string, label: string, skillsDir: string,
  *                       detect: (findings: object) => boolean,
- *                       invocation: (name: string) => string}>}
+ *                       invocation: (name: string) => string,
+ *                       hooksDir?: string,
+ *                       hooks?: ReadonlyArray<{name: string, file: string}>}>}
  */
 export const HARNESSES = Object.freeze([
   Object.freeze({
@@ -41,6 +56,10 @@ export const HARNESSES = Object.freeze([
     skillsDir: ".claude/skills",
     detect: (findings) => toolDetected(findings, "claude-code"),
     invocation: (name) => `/${name}`,
+    hooksDir: ".claude/hooks",
+    hooks: Object.freeze([
+      Object.freeze({ name: "session-orientation", file: "pathfinder-session-orientation.mjs" }),
+    ]),
   }),
   Object.freeze({
     id: "codex",