@nanobpm/agentic 0.1.0 → 0.4.0

package/src/session/normalizer/pi.ts

@@ -0,0 +1,75 @@
+/**
+ * pi / little-coder normalizer — ADR 0062 slice 3.
+ *
+ * Driven with `pi -p --mode json` (or `--mode rpc`): a JSON-RPC 2.0 notification
+ * stream. Session content arrives as `method` notifications
+ * (`session/message`, `session/reasoning`, `session/toolCall`,
+ * `session/toolResult`, `session/usage`) with a `params` payload. Restore is
+ * `--session-id <id>` (create-if-missing — the same flag both resumes an
+ * existing session and starts one under a chosen id); `-r` is the short alias and
+ * `--fork` branches. Streaming + resume-by-id → `durable-resume`.
+ */
+import type { DraftEvent, HarnessNormalizer, ResumeShim } from "./types.ts";
+import { asRecord, isRecord, optNumber, optString, reqString } from "./record.ts";
+
+const HARNESS = "pi";
+
+function params(obj: Record<string, unknown>): Record<string, unknown> {
+  return isRecord(obj.params) ? obj.params : {};
+}
+
+function toDrafts(record: unknown): readonly DraftEvent[] {
+  const obj = asRecord(HARNESS, record);
+  const method = obj.method;
+  if (typeof method !== "string") return []; // a JSON-RPC result/ack, not a notification
+  const p = params(obj);
+  switch (method) {
+    case "session/message": {
+      const text = optString(HARNESS, p, "text");
+      if (text === undefined || text.length === 0) return [];
+      const role = optString(HARNESS, p, "role");
+      return [{ type: role === "user" ? "user" : role === "system" ? "system" : "assistant", text }];
+    }
+    case "session/reasoning": {
+      const text = optString(HARNESS, p, "text");
+      const providerContinuation = optString(HARNESS, p, "continuation");
+      return [
+        {
+          type: "reasoning",
+          ...(text !== undefined ? { text } : {}),
+          ...(providerContinuation !== undefined ? { providerContinuation } : {}),
+        },
+      ];
+    }
+    case "session/toolCall": {
+      const callId = reqString(HARNESS, p, "id");
+      return [{ type: "tool-call", id: `call:${callId}`, callId, name: reqString(HARNESS, p, "name"), args: p.args }];
+    }
+    case "session/toolResult": {
+      const callId = reqString(HARNESS, p, "id");
+      return [{ type: "tool-result", id: `result:${callId}`, callId, ok: p.ok !== false, result: p.result }];
+    }
+    case "session/usage":
+      return [
+        {
+          type: "usage",
+          inputTokens: optNumber(HARNESS, p, "inputTokens") ?? 0,
+          outputTokens: optNumber(HARNESS, p, "outputTokens") ?? 0,
+          ...(typeof p.model === "string" ? { model: p.model } : {}),
+        },
+      ];
+    default:
+      return [];
+  }
+}
+
+export const piNormalizer: HarnessNormalizer = {
+  harness: HARNESS,
+  capabilities: { streaming: true, resumeById: true },
+  toDrafts,
+  resume(sessionId: string): ResumeShim {
+    // create-if-missing: `--session-id <id>` resumes it when it exists and starts
+    // it under that id when it does not.
+    return { transport: "cli", sessionId, args: ["--session-id", sessionId] };
+  },
+};

package/src/session/normalizer/probe.test.ts

@@ -0,0 +1,49 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { capabilityProbe, type HarnessNormalizer } from "./types.ts";
+import { FLEET_NORMALIZERS, normalizerFor, probeFleet } from "./index.ts";
+
+function syntheticNormalizer(streaming: boolean, resumeById: boolean): HarnessNormalizer {
+  return {
+    harness: `synthetic(${streaming},${resumeById})`,
+    capabilities: { streaming, resumeById },
+    toDrafts: () => [],
+    resume: (sessionId) => ({ transport: "cli", sessionId, args: [] }),
+  };
+}
+
+test("durable-resume is the AND of streaming and resume-by-id (derived, not declared)", () => {
+  assert.equal(capabilityProbe(syntheticNormalizer(true, true)).durableResume, true);
+  assert.equal(capabilityProbe(syntheticNormalizer(true, false)).durableResume, false, "a stream we cannot resume is not durable");
+  assert.equal(capabilityProbe(syntheticNormalizer(false, true)).durableResume, false, "a resume with no mind to replay is not durable");
+  assert.equal(capabilityProbe(syntheticNormalizer(false, false)).durableResume, false);
+});
+
+test("the probe echoes the raw capabilities alongside the derived bit", () => {
+  const ad = capabilityProbe(syntheticNormalizer(true, false));
+  assert.deepEqual(ad, {
+    harness: "synthetic(true,false)",
+    streaming: true,
+    resumeById: false,
+    durableResume: false,
+  });
+});
+
+test("every harness in the current fleet advertises durable-resume", () => {
+  const fleet = probeFleet();
+  assert.equal(fleet.length, FLEET_NORMALIZERS.length);
+  for (const ad of fleet) {
+    assert.equal(ad.durableResume, true, `${ad.harness} must advertise durable-resume`);
+    assert.equal(ad.streaming, true);
+    assert.equal(ad.resumeById, true);
+  }
+});
+
+test("the fleet registry covers exactly the documented harnesses, keyed by id", () => {
+  const harnesses = probeFleet().map((a) => a.harness).sort();
+  assert.deepEqual(harnesses, ["@github/copilot", "claude-code", "deepseek", "kimi", "pi", "qwen-code"]);
+  for (const n of FLEET_NORMALIZERS) {
+    assert.equal(normalizerFor(n.harness), n, "registry lookup returns the same instance");
+  }
+  assert.equal(normalizerFor("not-a-harness"), undefined);
+});

package/src/session/normalizer/qwen.test.ts

@@ -0,0 +1,20 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { normalizeSession } from "./link.ts";
+import { qwenNormalizer } from "./qwen.ts";
+
+test("qwen maps a system-role content frame to a system event", () => {
+  const events = normalizeSession(qwenNormalizer, [{ type: "content", role: "system", text: "you are nano" }]);
+  assert.equal(events.length, 1);
+  assert.equal(events[0].type, "system");
+});
+
+test("qwen keeps the assistant fallback for an unknown role", () => {
+  const events = normalizeSession(qwenNormalizer, [{ type: "content", role: "model", text: "here is the plan" }]);
+  assert.equal(events[0].type, "assistant");
+});
+
+test("qwen maps a user-role content frame to a user event", () => {
+  const events = normalizeSession(qwenNormalizer, [{ type: "content", role: "user", text: "please refactor" }]);
+  assert.equal(events[0].type, "user");
+});

package/src/session/normalizer/qwen.ts

@@ -0,0 +1,77 @@
+/**
+ * Qwen Code normalizer — ADR 0062 slice 3.
+ *
+ * Driven with `qwen -p -o stream-json`. Qwen Code descends from the Gemini CLI,
+ * so its streaming dialect speaks that lineage: `content` frames tagged with a
+ * `role`, `thought` frames for reasoning, and `tool_call_request` /
+ * `tool_call_response` pairs. Restore is `-r <id>` (`-c` continues the latest).
+ * Streaming + resume-by-id → `durable-resume`.
+ */
+import type { DraftEvent, HarnessNormalizer, ResumeShim } from "./types.ts";
+import { asRecord, optNumber, optString, reqString } from "./record.ts";
+
+const HARNESS = "qwen-code";
+
+function toDrafts(record: unknown): readonly DraftEvent[] {
+  const obj = asRecord(HARNESS, record);
+  switch (obj.type) {
+    case "content": {
+      const role = optString(HARNESS, obj, "role");
+      const text = optString(HARNESS, obj, "text");
+      if (text === undefined || text.length === 0) return [];
+      return [{ type: role === "user" ? "user" : role === "system" ? "system" : "assistant", text }];
+    }
+    case "thought": {
+      // Gemini-lineage reasoning: a bold `subject` + `description` body.
+      const subject = optString(HARNESS, obj, "subject");
+      const description = optString(HARNESS, obj, "description");
+      const text = [subject, description].filter((s): s is string => s !== undefined && s.length > 0).join(": ");
+      const providerContinuation = optString(HARNESS, obj, "thoughtSignature");
+      return [
+        {
+          type: "reasoning",
+          ...(text.length > 0 ? { text } : {}),
+          ...(providerContinuation !== undefined ? { providerContinuation } : {}),
+        },
+      ];
+    }
+    case "tool_call_request": {
+      const callId = reqString(HARNESS, obj, "callId");
+      return [
+        { type: "tool-call", id: `call:${callId}`, callId, name: reqString(HARNESS, obj, "name"), args: obj.args },
+      ];
+    }
+    case "tool_call_response": {
+      const callId = reqString(HARNESS, obj, "callId");
+      return [
+        {
+          type: "tool-result",
+          id: `result:${callId}`,
+          callId,
+          ok: obj.error == null,
+          result: obj.responseParts ?? obj.error,
+        },
+      ];
+    }
+    case "usage_metadata":
+      return [
+        {
+          type: "usage",
+          inputTokens: optNumber(HARNESS, obj, "promptTokenCount") ?? 0,
+          outputTokens: optNumber(HARNESS, obj, "candidatesTokenCount") ?? 0,
+          ...(typeof obj.model === "string" ? { model: obj.model } : {}),
+        },
+      ];
+    default:
+      return [];
+  }
+}
+
+export const qwenNormalizer: HarnessNormalizer = {
+  harness: HARNESS,
+  capabilities: { streaming: true, resumeById: true },
+  toDrafts,
+  resume(sessionId: string): ResumeShim {
+    return { transport: "cli", sessionId, args: ["-r", sessionId] };
+  },
+};

package/src/session/normalizer/record.test.ts

@@ -0,0 +1,68 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { asArray, asRecord, optNumber, optString, reqString } from "./record.ts";
+import { NormalizerDialectError } from "./types.ts";
+
+test("asRecord reports an array distinctly from a plain object", () => {
+  assert.throws(
+    () => asRecord("h", [1, 2, 3]),
+    (err: unknown) => err instanceof NormalizerDialectError && /got array$/.test(err.message),
+  );
+});
+
+test("asRecord reports null distinctly", () => {
+  assert.throws(
+    () => asRecord("h", null),
+    (err: unknown) => err instanceof NormalizerDialectError && /got null$/.test(err.message),
+  );
+});
+
+test("asRecord reports a primitive by its typeof", () => {
+  assert.throws(
+    () => asRecord("h", 7),
+    (err: unknown) => err instanceof NormalizerDialectError && /got number$/.test(err.message),
+  );
+});
+
+test("asArray reports null distinctly from a plain object", () => {
+  assert.throws(
+    () => asArray("h", null, "message.content"),
+    (err: unknown) =>
+      err instanceof NormalizerDialectError && /message\.content must be an array, got null$/.test(err.message),
+  );
+});
+
+test("asArray reports a primitive by its typeof", () => {
+  assert.throws(
+    () => asArray("h", "x", "message.content"),
+    (err: unknown) => err instanceof NormalizerDialectError && /got string$/.test(err.message),
+  );
+});
+
+test("reqString reports null distinctly from a plain object", () => {
+  assert.throws(
+    () => reqString("h", { f: null }, "f"),
+    (err: unknown) => err instanceof NormalizerDialectError && /got null$/.test(err.message),
+  );
+});
+
+test("reqString reports an array distinctly from a plain object", () => {
+  assert.throws(
+    () => reqString("h", { f: [1] }, "f"),
+    (err: unknown) => err instanceof NormalizerDialectError && /got array$/.test(err.message),
+  );
+});
+
+test("optString reports an array distinctly (present but wrong type)", () => {
+  assert.throws(
+    () => optString("h", { f: [1] }, "f"),
+    (err: unknown) => err instanceof NormalizerDialectError && /got array$/.test(err.message),
+  );
+});
+
+test("optNumber reports an array distinctly (present but wrong type)", () => {
+  assert.throws(
+    () => optNumber("h", { f: [1] }, "f"),
+    (err: unknown) => err instanceof NormalizerDialectError && /got array$/.test(err.message),
+  );
+});

package/src/session/normalizer/record.ts

@@ -0,0 +1,88 @@
+/**
+ * Small untyped-record inspection helpers shared by the per-harness dialect maps
+ * (ADR 0062 slice 3). A native record is untyped input (a `JSON.parse`d
+ * `stream-json` line, an SDK event object), so every dialect narrows it the same
+ * way: is-it-an-object, read-a-string, read-an-optional-string. Centralising the
+ * narrowing keeps the dialects declarative and, crucially, keeps them free of
+ * `as`-casts (AGENTS.md) — they narrow through these guards instead.
+ */
+import { NormalizerDialectError } from "./types.ts";
+
+/** True for a plain (non-array) object; the shape every native record must have. */
+export function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+/** Describe a value for a dialect error: distinguishes `null` and `array` from the bare `typeof`. */
+function describeType(value: unknown): string {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return "array";
+  return typeof value;
+}
+
+/** Narrow to a record or throw a dialect error attributing the harness. */
+export function asRecord(harness: string, value: unknown): Record<string, unknown> {
+  if (!isRecord(value)) {
+    throw new NormalizerDialectError(harness, `record must be a plain object, got ${describeType(value)}`);
+  }
+  return value;
+}
+
+/** Read a required string field or throw a dialect error. */
+export function reqString(harness: string, obj: Record<string, unknown>, field: string): string {
+  const v = obj[field];
+  if (typeof v !== "string") {
+    throw new NormalizerDialectError(harness, `field "${field}" must be a string, got ${describeType(v)}`);
+  }
+  return v;
+}
+
+/** Read an optional string field (undefined when absent), throwing on a wrong type. */
+export function optString(harness: string, obj: Record<string, unknown>, field: string): string | undefined {
+  const v = obj[field];
+  if (v === undefined || v === null) return undefined;
+  if (typeof v !== "string") {
+    throw new NormalizerDialectError(harness, `field "${field}" must be a string when present, got ${describeType(v)}`);
+  }
+  return v;
+}
+
+/** Read an optional finite number field, coercing absent/null to `undefined`. */
+export function optNumber(harness: string, obj: Record<string, unknown>, field: string): number | undefined {
+  const v = obj[field];
+  if (v === undefined || v === null) return undefined;
+  if (typeof v !== "number" || !Number.isFinite(v)) {
+    throw new NormalizerDialectError(harness, `field "${field}" must be a finite number when present, got ${describeType(v)}`);
+  }
+  return v;
+}
+
+/** Narrow to an array or throw a dialect error. */
+export function asArray(harness: string, value: unknown, what: string): readonly unknown[] {
+  if (!Array.isArray(value)) {
+    throw new NormalizerDialectError(harness, `${what} must be an array, got ${describeType(value)}`);
+  }
+  return value;
+}
+
+/**
+ * Collapse a message-content value to plain text. Harnesses model an assistant
+ * message either as a bare string or as an array of typed content parts
+ * (`{ type: "text", text }`); we concatenate the text parts and ignore the rest
+ * (tool-use parts are lifted to their own events by the dialect). Returns
+ * `undefined` when there is no text to emit so the dialect can skip an empty
+ * message.
+ */
+export function contentText(value: unknown): string | undefined {
+  if (typeof value === "string") return value.length > 0 ? value : undefined;
+  if (!Array.isArray(value)) return undefined;
+  let text = "";
+  for (const part of value) {
+    if (typeof part === "string") {
+      text += part;
+    } else if (isRecord(part) && part.type === "text" && typeof part.text === "string") {
+      text += part.text;
+    }
+  }
+  return text.length > 0 ? text : undefined;
+}

package/src/session/normalizer/resume.test.ts

@@ -0,0 +1,25 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { claudeNormalizer } from "./claude.ts";
+import { copilotNormalizer } from "./copilot.ts";
+import { deepseekNormalizer } from "./deepseek.ts";
+import { kimiNormalizer } from "./kimi.ts";
+import { piNormalizer } from "./pi.ts";
+import { qwenNormalizer } from "./qwen.ts";
+
+test("each harness resume shim maps a session id to its native restore invocation", () => {
+  assert.deepEqual(copilotNormalizer.resume("s1"), { transport: "sdk", sessionId: "s1", call: "resumeSession", args: ["s1"] });
+  assert.deepEqual(deepseekNormalizer.resume("s1"), { transport: "sdk", sessionId: "s1", call: "restore", args: ["s1"] });
+  assert.deepEqual(claudeNormalizer.resume("s1"), { transport: "cli", sessionId: "s1", args: ["--resume", "s1"] });
+  assert.deepEqual(qwenNormalizer.resume("s1"), { transport: "cli", sessionId: "s1", args: ["-r", "s1"] });
+  assert.deepEqual(kimiNormalizer.resume("s1"), { transport: "cli", sessionId: "s1", args: ["-S", "s1"] });
+  assert.deepEqual(piNormalizer.resume("s1"), { transport: "cli", sessionId: "s1", args: ["--session-id", "s1"] });
+});
+
+test("cli resume shims append the id as its own argv token (no shell-injection seam)", () => {
+  const shim = claudeNormalizer.resume("id with spaces");
+  assert.equal(shim.transport, "cli");
+  if (shim.transport === "cli") {
+    assert.deepEqual(shim.args, ["--resume", "id with spaces"]);
+  }
+});

package/src/session/normalizer/types.ts

@@ -0,0 +1,152 @@
+/**
+ * The `@nanobpm/agentic/session/normalizer` contract — ADR 0062, slice 3 (the
+ * `stream-json`/native-transcript **fallback** ingestion backend).
+ *
+ * Slice 2 speaks ACP directly; this slice covers every harness that does *not*
+ * (yet) speak ACP. ADR 0062 §5 frames `stream-json` as a *transport with N
+ * vendor dialects*, so there is no single "stream-json backend": each harness
+ * gets a small **normalizer** that maps its native/streaming session output onto
+ * Nano's canonical {@link SessionEvent} (slice 1), plus a **resume shim** over
+ * that harness's native `--resume <id>` (or SDK equivalent).
+ *
+ * The three moving parts a harness normalizer exposes:
+ *
+ *  - {@link HarnessNormalizer.toDrafts} — the dialect map: one native record →
+ *    zero-or-more {@link DraftEvent}s (canonical events *minus* the causal-chain
+ *    fields the shared {@link linkDrafts} threads in, so a per-harness dialect
+ *    never re-implements chaining).
+ *  - {@link HarnessNormalizer.resume} — the resume shim: given a native session
+ *    id, the exact native invocation ({@link ResumeShim}) that restores it.
+ *  - {@link HarnessNormalizer.capabilities} — the {@link HarnessCapabilities}
+ *    the {@link capabilityProbe} folds into a `durable-resume` advertisement
+ *    (slice 5's enrolment gate reads this).
+ *
+ * Nothing here interprets a harness schema as *ours*: the native shapes are
+ * ingestion details owned entirely by each dialect module; the union they all
+ * target is the stable slice-1 contract.
+ */
+import type { SessionEvent } from "../events.ts";
+
+/**
+ * Distributive `Omit` over a discriminated union: applies `Omit` to *each* union
+ * member, preserving the `type` discriminant. A plain `Omit<Union, K>` collapses
+ * to the members' common properties (losing the per-member fields), so we cannot
+ * use it to describe "a session event without its chain fields".
+ */
+export type DistributiveOmit<T, K extends keyof T> = T extends unknown ? Omit<T, K> : never;
+
+/**
+ * A canonical {@link SessionEvent} as a dialect first produces it — the full
+ * semantic payload (`type` + type-specific fields) but *without* the causal-chain
+ * responsibilities (`parentId`, and an optional-only `id`). The shared
+ * {@link linkDrafts} threads `parentId` in emission order and fills any missing
+ * `id`, so an individual dialect never re-implements chain bookkeeping; it just
+ * says "here is the event this record means". A dialect that already knows a
+ * stable native id (a tool-call id, a provider message id) may supply it as
+ * `id` to preserve correlation across a resume.
+ */
+export type DraftEvent = DistributiveOmit<SessionEvent, "id" | "parentId"> & {
+  readonly id?: string;
+};
+
+/**
+ * The native resume invocation a harness's shim resolves for a session id. Two
+ * transports cover the fleet:
+ *
+ *  - `cli` — a flag-driven harness: `args` are the argv tail to append to the
+ *    harness command to resume that session (e.g. Claude's `["--resume", id]`,
+ *    Qwen's `["-r", id]`). Nano spawns; it never parses the harness's output
+ *    beyond the dialect map.
+ *  - `sdk` — an in-process harness (Copilot's `copilot-sdk`, the DeepSeek live
+ *    feed): `call` names the SDK method and `args` are its arguments (e.g.
+ *    `resumeSession(id)`), so the host invokes it directly rather than spawning.
+ *
+ * `sessionId` echoes the id the shim resumed, so a caller that only kept the
+ * {@link ResumeShim} still knows which session it targets.
+ */
+export type ResumeShim =
+  | { readonly transport: "cli"; readonly sessionId: string; readonly args: readonly string[] }
+  | { readonly transport: "sdk"; readonly sessionId: string; readonly call: string; readonly args: readonly unknown[] };
+
+/**
+ * What a harness can do, from the perspective of durable resume. `streaming` is
+ * "exposes a machine-readable streaming/native mind source we can normalize";
+ * `resumeById` is "can restore a *specific* prior session by id" (not merely
+ * `--continue` the latest). {@link CapabilityAdvertisement.durableResume} is
+ * derived, never declared — see {@link capabilityProbe}.
+ */
+export interface HarnessCapabilities {
+  readonly streaming: boolean;
+  readonly resumeById: boolean;
+}
+
+/**
+ * The advertisement {@link capabilityProbe} produces: the raw capabilities plus
+ * the single **derived** `durableResume` bit slice 5's enrolment gate consumes.
+ * Keeping `durableResume` derived (never a hand-set field on a normalizer)
+ * eliminates the drift surface where a harness claims durability it can't honour.
+ */
+export interface CapabilityAdvertisement {
+  readonly harness: string;
+  readonly streaming: boolean;
+  readonly resumeById: boolean;
+  /** `true` iff the harness both streams a mind source AND resumes by id. */
+  readonly durableResume: boolean;
+}
+
+/**
+ * One harness's fallback ingestion adapter: a dialect map, a resume shim, and its
+ * capabilities. Independent per harness (they fan out in parallel), and all
+ * target the one canonical {@link SessionEvent} union.
+ */
+export interface HarnessNormalizer {
+  /** The harness id this normalizer speaks for, e.g. `"@github/copilot"`. */
+  readonly harness: string;
+  /** Raw capabilities; `durable-resume` is derived from these by {@link capabilityProbe}. */
+  readonly capabilities: HarnessCapabilities;
+  /**
+   * Map one native record (a parsed `stream-json` line, an SDK `SessionEvent`, a
+   * live-feed frame) to zero-or-more canonical {@link DraftEvent}s. Returns `[]`
+   * for records that carry no session-log meaning (transport keep-alives, init
+   * frames the canonical model does not represent). Throws
+   * {@link NormalizerDialectError} on a record that *should* map but is
+   * structurally invalid — a corrupt transcript fails loudly, it never
+   * fabricates an event.
+   */
+  toDrafts(record: unknown): readonly DraftEvent[];
+  /** Resolve the native invocation that resumes `sessionId` for this harness. */
+  resume(sessionId: string): ResumeShim;
+}
+
+/**
+ * Derive a harness's `durable-resume` advertisement from its raw capabilities.
+ * A harness advertises `durable-resume` **iff** it both exposes a streaming mind
+ * source we can normalize AND can restore a specific session by id — either half
+ * alone is insufficient (a stream we can't resume, or a resume with no mind to
+ * replay). This is the single place the bit is computed.
+ */
+export function capabilityProbe(normalizer: HarnessNormalizer): CapabilityAdvertisement {
+  const { streaming, resumeById } = normalizer.capabilities;
+  return {
+    harness: normalizer.harness,
+    streaming,
+    resumeById,
+    durableResume: streaming && resumeById,
+  };
+}
+
+/**
+ * Raised when a native record that a dialect *should* map is structurally
+ * invalid (a missing tool-call id, a message with no content). Mirrors slice 1's
+ * `SessionEventShapeError` at the ingestion boundary: normalization is a trusted
+ * map, so a malformed native record surfaces loudly rather than silently
+ * dropping or fabricating a canonical event.
+ */
+export class NormalizerDialectError extends Error {
+  readonly harness: string;
+  constructor(harness: string, message: string) {
+    super(`[${harness}] ${message}`);
+    this.name = "NormalizerDialectError";
+    this.harness = harness;
+  }
+}