create-pathfinder 4.1.0 → 4.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pathfinder",
-  "version": "4.1.0",
+  "version": "4.2.0",
   "description": "Install Pathfinder's ticket-first, human-in-the-loop workflow kit into a Git repository.",
   "keywords": [
     "pathfinder",

package/src/activation.mjs

@@ -0,0 +1,199 @@
+/**
+ * What a human does to turn a generated handler on, and how they turn it off.
+ *
+ * Pathfinder generates the handler and stops. Activation is native harness
+ * configuration in a file Pathfinder does not own, does not read, and never
+ * writes — so the only thing this package can offer is the exact text to paste
+ * and an honest account of what happens if nobody pastes it.
+ *
+ * That is why this module is prose and nothing else. It imports no `node:fs`,
+ * holds no path to a settings file it might one day open, and returns strings.
+ * `test/hooks.test.mjs` asserts both halves of that: this is the one module
+ * under `src/` allowed to name a settings file, and it is allowed to precisely
+ * because it cannot act on one.
+ *
+ * The fragment is built from the registry's stable handler path rather than
+ * written out, so a fragment that no longer matches what the installer
+ * generates is not a thing this package can print.
+ *
+ * The handler ships mode 0644 and is not executable, whatever its shebang
+ * says, so the command runs it through Node. `$CLAUDE_PROJECT_DIR` is what
+ * keeps the activation correct from a subdirectory and inside a worktree.
+ */
+
+import { HARNESSES } from "./harnesses/index.mjs";
+import { hookPath, hooksFor } from "./harnesses/hook.mjs";
+
+/** Where a human puts the fragment. The first is the documented default. */
+export const DEFAULT_SURFACE = ".claude/settings.local.json";
+export const SHARED_SURFACE = ".claude/settings.json";
+
+/**
+ * Does this harness declare that it can run a handler at all?
+ *
+ * Read from the registry — `hooksDir` is the field that says "this tool has a
+ * place handlers go" — rather than from the length of `hooks`, which is the
+ * thing being checked. Codex answers no, and that is a correct answer, not a
+ * gap: it gets no handler and no activation prose.
+ */
+export function supportsActivation(harness) {
+  return typeof harness?.hooksDir === "string" && harness.hooksDir !== "";
+}
+
+/**
+ * The one handler a capable harness activates, or null for a harness that has
+ * no place to put one.
+ *
+ * v1 ships exactly one orientation handler per capable harness, and this is
+ * where that assumption is stated instead of assumed. `hooksFor(harness)[0]`
+ * reads identically whether the registry holds one handler, none, or three —
+ * which is precisely the property that makes it unsafe: a registry that lost
+ * its hook would print no fragment and a registry that grew a second one would
+ * silently document the first. Both are wrong, and both are silent.
+ *
+ * So a capable harness that does not resolve to exactly one handler throws.
+ * Callers that legitimately have nothing to say — a Codex run — are served by
+ * the null, not by the throw.
+ *
+ * @throws {Error} when the registry and this assumption disagree.
+ */
+export function activationHandler(harness) {
+  const hooks = hooksFor(harness);
+
+  if (!supportsActivation(harness)) {
+    if (hooks.length > 0) {
+      throw new Error(
+        `activation: ${harness?.id ?? "harness"} declares ${hooks.length} handler(s) ` +
+          "but no hooksDir to put them in",
+      );
+    }
+    return null;
+  }
+
+  if (hooks.length !== 1) {
+    throw new Error(
+      `activation: ${harness.id} supports session orientation, so exactly one handler ` +
+        `must resolve; the registry gives ${hooks.length}`,
+    );
+  }
+
+  return hooks[0];
+}
+
+/**
+ * Every harness this build can print activation for, with its handler.
+ *
+ * Exported for `validate-kit.py`, which needs the set rather than one harness:
+ * checking the guide against `claude-code` alone would pass unchanged on the
+ * day a second capable harness is added and left undocumented.
+ *
+ * Throws for the same reasons `activationHandler` does, which is the point —
+ * a validator that enumerates this cannot pass vacuously.
+ */
+export function activationTargets() {
+  return HARNESSES.map((harness) => ({ harness, hook: activationHandler(harness) })).filter(
+    ({ hook }) => hook !== null,
+  );
+}
+
+/**
+ * The command that runs one handler, quoted for a shell.
+ *
+ * Exported for the documentation build and the tests, which check the site and
+ * the installer against one spelling rather than two.
+ */
+export function activationCommand(harness, hook) {
+  return `node "$CLAUDE_PROJECT_DIR/${hookPath(harness, hook)}"`;
+}
+
+/**
+ * The native fragment, as the lines a person pastes.
+ *
+ * The matcher is deliberately omitted, so one entry covers the lifecycle
+ * sources without naming any of them.
+ *
+ * `startup`, `resume`, `clear`, and `compact` were each observed live per
+ * source against a real install, not inferred from `startup`. `fork` was not:
+ * the reachable surface, `claude --resume --fork-session`, emits
+ * `source: "resume"`, so it was covered by driving the handler with a `fork`
+ * payload instead. The handler branches on the source for nothing, which is
+ * what bounds what that weaker evidence can cost.
+ */
+export function activationFragmentLines(harness, hook) {
+  return [
+    "{",
+    '  "hooks": {',
+    '    "SessionStart": [',
+    "      {",
+    '        "hooks": [',
+    "          {",
+    '            "type": "command",',
+    `            "command": ${JSON.stringify(activationCommand(harness, hook))}`,
+    "          }",
+    "        ]",
+    "      }",
+    "    ]",
+    "  }",
+    "}",
+  ];
+}
+
+/**
+ * The whole activation note for one harness, as undecorated lines.
+ *
+ * Returned as text rather than printed, so the two renderings in `cli.mjs`
+ * decorate one set of sentences instead of each keeping their own copy — the
+ * same reason `outcome.mjs` exists. Empty for a harness with no handler, which
+ * is how a Codex run says nothing at all about activation.
+ *
+ * `dryRun` changes tense and nothing else. A dry run has written no handler, so
+ * a note that says "the handler is inert" is describing a file that is not
+ * there — the one sentence on that screen a reader could act on and be wrong
+ * about. The fragment itself is identical in both modes, because the path it
+ * points at is the path the real run will write.
+ *
+ * The unactivated answer is stated in the same breath as the fragment, because
+ * a reader who decides not to paste it is owed the consequence on the same
+ * screen: no automatic orientation, and `/whereami` on demand.
+ */
+export function activationLines(harness, { dryRun = false } = {}) {
+  const hook = activationHandler(harness);
+  if (!hook) return [];
+
+  const opening = dryRun
+    ? [
+        "The handler would be inert. Once installed it would run only if you add",
+        `this to ${DEFAULT_SURFACE}:`,
+      ]
+    : [
+        "The handler is inert. It runs only if you add this to",
+        `${DEFAULT_SURFACE}:`,
+      ];
+
+  const closing = dryRun
+    ? [
+        "Without the fragment there would be no automatic orientation. Nothing else",
+        "would change: run /whereami whenever you want the same picture.",
+        "To remove it later, delete the handler and drop the fragment. Either order",
+        "is fine, and so is doing only one: an unreferenced handler never runs.",
+        "A fragment for a missing handler is a no-op that cannot block a session.",
+      ]
+    : [
+        "Without the fragment there is no automatic orientation. Nothing else",
+        "changes: run /whereami whenever you want the same picture.",
+        "To remove it later, delete the handler and drop the fragment. Either order",
+        "is fine, and so is doing only one: an unreferenced handler never runs.",
+        "A fragment for a missing handler is a no-op that cannot block a session.",
+      ];
+
+  return [
+    ...opening,
+    "",
+    ...activationFragmentLines(harness, hook),
+    "",
+    `${DEFAULT_SURFACE} keeps the choice yours and`,
+    `per-machine. Use ${SHARED_SURFACE} only to turn it on for everyone`,
+    "who clones the repository.",
+    ...closing,
+  ];
+}

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,
   };
 }