@twelvehart/orcats 0.0.0-seed.0 → 0.2.3

package/src/loop/state/sqlite.ts

@@ -0,0 +1,265 @@
+import { Database } from "bun:sqlite";
+import { createHash, randomUUID } from "node:crypto";
+import { err, ok, type Result } from "neverthrow";
+import type { RuntimeError } from "../../model/index.ts";
+import { parseManifest, type TaskManifest } from "./manifest.ts";
+import { stateHash } from "./snapshot.ts";
+import type { BranchWritableStateStore, StateHash, StateReducer } from "./port.ts";
+
+// `sqlite` is the escalate-for-durability adapter (design D4): per-step checkpoints
+// to a single WAL file plus lease-based crash recovery — finer resume than
+// `snapshot`, still no service and no install (bun:sqlite is built into Bun).
+// LangGraph's `better-sqlite3` saver fails on Bun (native ABI mismatch), so this is
+// hand-rolled directly on `bun:sqlite`. It implements the SAME `StateStore` port as
+// `snapshot`: loop code targets the port, so selecting this adapter needs no change
+// to a loop definition. State lives in three tables:
+//   - `snapshots(hash, manifest)` — content-addressed manifest JSON (checkpoints AND
+//     branch copies/results). Reuses `stateHash` so a manifest hashes identically
+//     across adapters; `INSERT OR REPLACE` keeps equal manifests deduplicated.
+//   - `history(seq, hash, created_at)` — the ordered cycle stream (time-travel). Only
+//     `checkpoint` appends; `branch`/`saveBranch` copies do NOT, matching `snapshot` history.
+//   - `lease(owner, heartbeat)` — a single advisory row for crash recovery, NOT a
+//     write lock: content-addressed snapshots + append-only history make concurrent
+//     writers safe-but-interleaved. A live foreign lease is refused at open; a stale
+//     one (holder crashed) is reclaimed, and the per-step-committed history is resumed.
+//
+// Durability boundary: every `checkpoint` commits in its own transaction and folds
+// the WAL into the main db (`wal_checkpoint`), so an interrupt loses at most the
+// in-flight step — a fresh store on the same file recovers `history()`/`load()`.
+
+const DEFAULT_LEASE_TTL_MS = 30_000;
+
+const SCHEMA: readonly string[] = [
+  "CREATE TABLE IF NOT EXISTS snapshots (hash TEXT PRIMARY KEY, manifest TEXT NOT NULL)",
+  "CREATE TABLE IF NOT EXISTS history (seq INTEGER PRIMARY KEY AUTOINCREMENT, hash TEXT NOT NULL, created_at INTEGER NOT NULL)",
+  "CREATE TABLE IF NOT EXISTS lease (id INTEGER PRIMARY KEY CHECK (id = 1), owner TEXT NOT NULL, heartbeat INTEGER NOT NULL)"
+];
+
+export interface SqliteStoreOptions {
+  /** Database file path; durability and crash recovery require a real file
+   * (`:memory:` works but is lost on exit). */
+  readonly path: string;
+  /** Lease owner id for this runner; defaults to a random per-process id. */
+  readonly owner?: string;
+  /** A lease whose heartbeat is older than this many ms is treated as a crashed
+   * holder and reclaimed on open. */
+  readonly leaseTtlMs?: number;
+  /** Injectable clock (ms epoch) for deterministic lease tests; defaults to `Date.now`. */
+  readonly now?: () => number;
+}
+
+/**
+ * The `sqlite` adapter: a {@link StateStore} plus lease lifecycle controls. The
+ * extra members are NOT part of the port — loop code targets `StateStore` and never
+ * sees them, so swapping `snapshot` <-> `sqlite` needs no loop-definition change.
+ */
+export interface SqliteStore extends BranchWritableStateStore {
+  /** This runner's lease owner id. */
+  readonly owner: string;
+  /** Refresh the lease heartbeat mid-step so a long step keeps its lease;
+   * `err` once another runner has reclaimed a stale lease. */
+  heartbeat(): Result<void, RuntimeError>;
+  /** Release the lease and close the database (clean shutdown — not a crash). */
+  close(): void;
+}
+
+interface ManifestRow {
+  manifest: string;
+}
+interface HashRow {
+  hash: string;
+}
+interface LeaseRow {
+  owner: string;
+  heartbeat: number;
+}
+
+function fsErr(path: string, message: string): RuntimeError {
+  return { _tag: "FileSystemError", path, message };
+}
+
+export function createSqliteStore(options: SqliteStoreOptions): Result<SqliteStore, RuntimeError> {
+  const { path } = options;
+  const owner = options.owner ?? randomUUID();
+  const leaseTtlMs = options.leaseTtlMs ?? DEFAULT_LEASE_TTL_MS;
+  const now = options.now ?? Date.now;
+
+  let db: Database;
+  try {
+    db = new Database(path, { create: true });
+    db.run("PRAGMA journal_mode = WAL");
+    db.run("PRAGMA busy_timeout = 5000");
+    for (const statement of SCHEMA) {
+      db.run(statement);
+    }
+  } catch (error) {
+    return err(fsErr(path, `failed to open sqlite state store: ${String(error)}`));
+  }
+
+  const readSnapshot = (hash: StateHash): Result<TaskManifest, RuntimeError> => {
+    let row: ManifestRow | null;
+    try {
+      row = db.query<ManifestRow, [string]>("SELECT manifest FROM snapshots WHERE hash = ?").get(hash);
+    } catch (error) {
+      return err(fsErr(path, `failed to read snapshot ${hash}: ${String(error)}`));
+    }
+    if (row === null) {
+      return err(fsErr(path, `no snapshot for hash ${hash}`));
+    }
+    let raw: unknown;
+    try {
+      raw = JSON.parse(row.manifest);
+    } catch (error) {
+      return err(fsErr(path, `corrupt snapshot ${hash}: ${String(error)}`));
+    }
+    return parseManifest(raw);
+  };
+
+  const writeSnapshot = (hash: StateHash, manifest: TaskManifest): Result<void, RuntimeError> => {
+    try {
+      db.run("INSERT OR REPLACE INTO snapshots (hash, manifest) VALUES (?, ?)", [hash, JSON.stringify(manifest)]);
+      return ok(undefined);
+    } catch (error) {
+      return err(fsErr(path, `failed to write snapshot ${hash}: ${String(error)}`));
+    }
+  };
+
+  // Acquire the lease = the crash-recovery boundary. A fresh foreign lease means
+  // another runner is live (refuse); a stale or self-owned lease is reclaimed.
+  try {
+    const current = db.query<LeaseRow, []>("SELECT owner, heartbeat FROM lease WHERE id = 1").get();
+    const ts = now();
+    if (current === null) {
+      db.run("INSERT INTO lease (id, owner, heartbeat) VALUES (1, ?, ?)", [owner, ts]);
+    } else if (current.owner !== owner && ts - current.heartbeat <= leaseTtlMs) {
+      db.close();
+      return err(fsErr(path, `state store leased by "${current.owner}"; another runner is active`));
+    } else {
+      db.run("UPDATE lease SET owner = ?, heartbeat = ? WHERE id = 1", [owner, ts]);
+    }
+  } catch (error) {
+    db.close();
+    return err(fsErr(path, `lease acquisition failed: ${String(error)}`));
+  }
+
+  const store: SqliteStore = {
+    owner,
+
+    load(hash) {
+      if (hash !== undefined) {
+        return Promise.resolve(readSnapshot(hash));
+      }
+      let row: HashRow | null;
+      try {
+        row = db.query<HashRow, []>("SELECT hash FROM history ORDER BY seq DESC LIMIT 1").get();
+      } catch (error) {
+        return Promise.resolve(err(fsErr(path, `failed to read history: ${String(error)}`)));
+      }
+      if (row === null) {
+        return Promise.resolve(err(fsErr(path, "no checkpoint to load")));
+      }
+      return Promise.resolve(readSnapshot(row.hash));
+    },
+
+    checkpoint(state) {
+      const validated = parseManifest(state);
+      if (validated.isErr()) {
+        return Promise.resolve(err(validated.error));
+      }
+      const manifest = validated.value;
+      const hash = stateHash(manifest);
+      try {
+        // One transaction per step: snapshot + history row + lease heartbeat commit
+        // atomically, so an interrupt never leaves a half-written cycle.
+        const commit = db.transaction((m: TaskManifest, h: StateHash, ts: number) => {
+          db.run("INSERT OR REPLACE INTO snapshots (hash, manifest) VALUES (?, ?)", [h, JSON.stringify(m)]);
+          db.run("INSERT INTO history (hash, created_at) VALUES (?, ?)", [h, ts]);
+          db.run("UPDATE lease SET heartbeat = ? WHERE id = 1 AND owner = ?", [ts, owner]);
+        });
+        commit(manifest, hash, now());
+        db.run("PRAGMA wal_checkpoint(PASSIVE)");
+      } catch (error) {
+        return Promise.resolve(err(fsErr(path, `checkpoint failed: ${String(error)}`)));
+      }
+      return Promise.resolve(ok(hash));
+    },
+
+    branch(from) {
+      const source = readSnapshot(from);
+      if (source.isErr()) {
+        return Promise.resolve(err(source.error));
+      }
+      // Synthetic (non-content) hash so the isolated branch copy gets its own identity
+      // instead of colliding with `from` under content addressing.
+      const hash = createHash("sha256").update(`${from}:${randomUUID()}`).digest("hex").slice(0, 12);
+      const written = writeSnapshot(hash, source.value);
+      if (written.isErr()) {
+        return Promise.resolve(err(written.error));
+      }
+      return Promise.resolve(ok(hash));
+    },
+
+    saveBranch(branch, state) {
+      const source = readSnapshot(branch);
+      if (source.isErr()) {
+        return Promise.resolve(err(source.error));
+      }
+      const validated = parseManifest(state);
+      if (validated.isErr()) {
+        return Promise.resolve(err(validated.error));
+      }
+      const manifest = validated.value;
+      const hash = stateHash(manifest);
+      const written = writeSnapshot(hash, manifest);
+      if (written.isErr()) {
+        return Promise.resolve(err(written.error));
+      }
+      return Promise.resolve(ok(hash));
+    },
+
+    merge(branches, reducer: StateReducer<TaskManifest>) {
+      const states: TaskManifest[] = [];
+      for (const hash of branches) {
+        const loaded = readSnapshot(hash);
+        if (loaded.isErr()) {
+          return Promise.resolve(err(loaded.error));
+        }
+        states.push(loaded.value);
+      }
+      return Promise.resolve(parseManifest(reducer(states)));
+    },
+
+    history() {
+      try {
+        const rows = db.query<HashRow, []>("SELECT hash FROM history ORDER BY seq").all();
+        return Promise.resolve(ok(rows.map((row) => row.hash)));
+      } catch (error) {
+        return Promise.resolve(err(fsErr(path, `failed to read history: ${String(error)}`)));
+      }
+    },
+
+    heartbeat() {
+      try {
+        const result = db.run("UPDATE lease SET heartbeat = ? WHERE id = 1 AND owner = ?", [now(), owner]);
+        if (result.changes === 0) {
+          return err(fsErr(path, `lease lost by "${owner}"; another runner reclaimed the store`));
+        }
+        return ok(undefined);
+      } catch (error) {
+        return err(fsErr(path, `heartbeat failed: ${String(error)}`));
+      }
+    },
+
+    close() {
+      try {
+        db.run("DELETE FROM lease WHERE id = 1 AND owner = ?", [owner]);
+        db.run("PRAGMA wal_checkpoint(TRUNCATE)");
+      } catch {
+        // Best-effort lease release / WAL fold; closing the handle is what matters.
+      }
+      db.close();
+    }
+  };
+
+  return ok(store);
+}

package/src/loop/termination-contract.ts

@@ -0,0 +1,89 @@
+// Termination by construction (design D3 / tasks 4.5): enforced at build/lint time, before
+// any loop runs. A beneficial cycle provably terminates only if its back-edge carries a loop
+// variant — a measure bounded below that strictly decreases. The contract here rejects, with
+// the offending cycle NAMED, two ways a loop graph violates that:
+//
+//   1. An ACCIDENTAL cycle — a back-edge the author never declared. Undeclared cycles have no
+//      variant by definition and are reported.
+//   2. An UNGUARDED declared back-edge — a declared loop whose head carries neither a preset
+//      archetype nor a `.measure()` override.
+//
+// This module owns the SHAPE of the contract; it does not know about presets. It asks a
+// caller-supplied `HasVariant` predicate whether a given loop-head node has a variant. L06
+// satisfies that predicate by wiring preset archetypes (untilGatesGreen, untilManifestComplete,
+// …) and `.measure()` overrides onto nodes. Effect-free (neverthrow only); kept internal — the
+// builder surfaces the result, this file is not re-exported from ../index.ts.
+
+import { err, ok, type Result } from "neverthrow";
+
+import type { BackEdge, CycleReport, NodeId } from "./graph/index.ts";
+
+/**
+ * Predicate the contract queries per loop. L06 implements it by checking whether the back-edge's
+ * head node has a bound preset archetype or `.measure()` variant. Queried with the back-edge
+ * head (`BackEdge.to`) — the node a loop jumps back to.
+ */
+export type HasVariant = (node: NodeId) => boolean;
+
+export type CycleViolationKind = "unguarded-back-edge" | "accidental-cycle";
+
+export interface CycleViolation {
+  readonly kind: CycleViolationKind;
+  readonly backEdge: BackEdge;
+  /** The cycle's node path, used to name it in the message. */
+  readonly cycle: readonly NodeId[];
+}
+
+export interface TerminationContractError {
+  readonly _tag: "TerminationContractViolated";
+  readonly violations: readonly CycleViolation[];
+  /** Human-readable summary naming every offending cycle. */
+  readonly message: string;
+}
+
+/** Render a cycle path as `a → b → c → a` so the loop is named, not just counted. */
+function nameCycle(cycle: readonly NodeId[]): string {
+  const first = cycle[0];
+  if (first === undefined) return "(empty)";
+  if (cycle.length === 1) return `${first} → ${first}`;
+  const last = cycle[cycle.length - 1];
+  const closed = last === first ? cycle : [...cycle, first];
+  return closed.join(" → ");
+}
+
+function describe(v: CycleViolation): string {
+  const named = nameCycle(v.cycle);
+  return v.kind === "accidental-cycle"
+    ? `accidental cycle ${named} — declare it as a loop back-edge or remove an edge`
+    : `unguarded back-edge ${v.backEdge.from} → ${v.backEdge.to} closing cycle ${named} — ` +
+        `add a preset archetype or .measure() to node "${v.backEdge.to}"`;
+}
+
+/**
+ * Enforce the termination contract over an analyzed loop graph. Returns `ok` when every cycle is
+ * a declared loop back-edge whose head carries a variant; otherwise `err` naming each offending
+ * cycle. Collects ALL violations in one pass so the author sees every problem at once.
+ */
+export function enforceTerminationContract(
+  report: CycleReport,
+  hasVariant: HasVariant
+): Result<void, TerminationContractError> {
+  const violations: CycleViolation[] = [];
+
+  for (const backEdge of report.backEdges) {
+    if (!backEdge.declared) {
+      violations.push({ kind: "accidental-cycle", backEdge, cycle: backEdge.cycle });
+    } else if (!hasVariant(backEdge.to)) {
+      violations.push({ kind: "unguarded-back-edge", backEdge, cycle: backEdge.cycle });
+    }
+  }
+
+  if (violations.length === 0) return ok(undefined);
+
+  const count = violations.length;
+  const message =
+    `Loop graph violates termination by construction (${String(count)} ` +
+    `${count === 1 ? "cycle" : "cycles"}): ${violations.map(describe).join("; ")}.`;
+
+  return err({ _tag: "TerminationContractViolated", violations, message });
+}

package/src/loop/termination.ts

@@ -0,0 +1,156 @@
+import type { Usage } from "../model/index.ts";
+
+export interface FingerprintAction {
+  readonly identity: string;
+  readonly inputs: unknown;
+}
+
+export interface FingerprintDetectorOptions<T> {
+  readonly project: (value: T) => FingerprintAction | undefined;
+  /** Number of recent fingerprints retained for repeat detection. */
+  readonly windowSize?: number;
+  /** Repeated occurrences within the window required to declare stuck. */
+  readonly repeatThreshold?: number;
+}
+
+export type TokenUsageSummary =
+  | { readonly kind: "known"; readonly total: number; readonly budget?: number }
+  | { readonly kind: "unknown"; readonly knownTotal: number; readonly budget?: number };
+
+export function usageTokens(usage: Usage): number {
+  return usage.input + usage.output + (usage.reasoning ?? 0);
+}
+
+export class TokenBudgetCounter {
+  readonly #budget: number | undefined;
+  #knownTotal = 0;
+  #unknown = false;
+  #knownRecords = 0;
+
+  constructor(budget?: number) {
+    this.#budget = budget;
+  }
+
+  record(usage: Usage | undefined): void {
+    if (usage === undefined) {
+      this.#unknown = true;
+      return;
+    }
+    this.#knownRecords++;
+    this.#knownTotal += usageTokens(usage);
+  }
+
+  get shouldReport(): boolean {
+    return this.#budget !== undefined || this.#knownRecords > 0;
+  }
+
+  get exhausted(): boolean {
+    return this.#budget !== undefined && !this.#unknown && this.#knownTotal > this.#budget;
+  }
+
+  summary(): TokenUsageSummary {
+    if (this.#unknown) {
+      return withBudget({ kind: "unknown", knownTotal: this.#knownTotal }, this.#budget);
+    }
+    return withBudget({ kind: "known", total: this.#knownTotal }, this.#budget);
+  }
+}
+
+export function makeFingerprintStuckDetector<T>(
+  options: FingerprintDetectorOptions<T>
+): (value: T) => boolean {
+  const repeatThreshold = options.repeatThreshold ?? 2;
+  const windowSize = Math.max(options.windowSize ?? 3, repeatThreshold);
+  const window: string[] = [];
+  const counts = new Map<string, number>();
+
+  return (value: T): boolean => {
+    const projected = options.project(value);
+    if (projected === undefined) {
+      return false;
+    }
+
+    const fingerprint = fingerprintAction(projected);
+    window.push(fingerprint);
+    counts.set(fingerprint, (counts.get(fingerprint) ?? 0) + 1);
+
+    if (window.length > windowSize) {
+      const expired = window.shift();
+      if (expired !== undefined) {
+        const remaining = (counts.get(expired) ?? 1) - 1;
+        if (remaining <= 0) {
+          counts.delete(expired);
+        } else {
+          counts.set(expired, remaining);
+        }
+      }
+    }
+
+    return (counts.get(fingerprint) ?? 0) >= repeatThreshold;
+  };
+}
+
+export function fingerprintAction(action: FingerprintAction): string {
+  return fnv1a32(`${action.identity}\u0000${stableStringify(action.inputs)}`);
+}
+
+function withBudget<T extends { readonly kind: "known" | "unknown" }>(
+  summary: T,
+  budget: number | undefined
+): T | (T & { readonly budget: number }) {
+  if (budget === undefined) {
+    return summary;
+  }
+  return { ...summary, budget };
+}
+
+function stableStringify(value: unknown, seen = new WeakSet<object>()): string {
+  if (value === null) {
+    return "null";
+  }
+
+  switch (typeof value) {
+    case "string":
+      return JSON.stringify(value);
+    case "number":
+    case "boolean":
+      return String(value);
+    case "bigint":
+      return `${value.toString()}n`;
+    case "undefined":
+      return "undefined";
+    case "symbol":
+    case "function":
+      return String(value);
+    case "object":
+      break;
+  }
+
+  const objectValue = value;
+  if (seen.has(objectValue)) {
+    return "[Circular]";
+  }
+  seen.add(objectValue);
+
+  if (Array.isArray(objectValue)) {
+    const serialized = `[${objectValue.map((item) => stableStringify(item, seen)).join(",")}]`;
+    seen.delete(objectValue);
+    return serialized;
+  }
+
+  const entries = Object.entries(objectValue).sort(([left], [right]) => left.localeCompare(right));
+  const serialized = `{${entries
+    .map(([key, entryValue]) => `${JSON.stringify(key)}:${stableStringify(entryValue, seen)}`)
+    .join(",")}}`;
+  seen.delete(objectValue);
+  return serialized;
+}
+
+function fnv1a32(value: string): string {
+  let hash = 0x811c9dc5;
+  for (let index = 0; index < value.length; index++) {
+    hash ^= value.charCodeAt(index);
+    hash = Math.imul(hash, 0x01000193);
+  }
+  return (hash >>> 0).toString(16).padStart(8, "0");
+}

package/src/model/backend-config.ts

@@ -0,0 +1,34 @@
+import type { z } from "zod";
+import type { BackendTag, LlmResult } from "./schemas.ts";
+import type { SessionId } from "./brand.ts";
+
+export type BackendApprovalPolicy = "never" | "on-request" | "on-failure" | "granular" | "untrusted";
+export type BackendSandboxMode = "read-only" | "workspace-write" | "danger-full-access";
+
+export interface BackendRetryConfig {
+  readonly attempts: number;
+}
+
+export interface StructuredOutputConfig<Output = unknown> {
+  readonly schema: z.ZodType<Output>;
+  readonly name?: string;
+  readonly description?: string;
+}
+
+export interface BackendConfig<B extends BackendTag = BackendTag, Output = unknown> {
+  readonly model?: string;
+  readonly systemPrompt?: string;
+  readonly approvalPolicy?: BackendApprovalPolicy;
+  readonly readOnly?: boolean;
+  readonly sandbox?: BackendSandboxMode;
+  readonly selfManagedGit?: boolean;
+  readonly retry?: BackendRetryConfig;
+  readonly structuredOutput?: StructuredOutputConfig<Output>;
+  readonly resumeSessionId?: SessionId<B>;
+  readonly interactive?: boolean;
+}
+
+export type BackendResult<B extends BackendTag> = Omit<LlmResult, "backend" | "sessionId"> & {
+  readonly backend: B;
+  readonly sessionId: SessionId<B>;
+};

package/src/model/brand.ts

@@ -0,0 +1,11 @@
+import type { BackendTag } from "./schemas.ts";
+
+declare const brand: unique symbol;
+
+export type Brand<T, Name extends string> = T & { readonly [brand]: Name };
+
+export type SessionId<B extends BackendTag> = Brand<string, `SessionId:${B}`>;
+
+export function sessionId<B extends BackendTag>(backend: B, value: string): SessionId<B> {
+  return value as SessionId<B>;
+}

package/src/model/errors.ts

@@ -0,0 +1,28 @@
+import type { BackendTag, RuntimeError } from "./schemas.ts";
+
+type RuntimeErrorArgs<Tag extends RuntimeError["_tag"]> = Omit<
+  Extract<RuntimeError, { _tag: Tag }>,
+  "_tag"
+>;
+
+export function unsupportedFeature(feature: string, reason: string): RuntimeError {
+  return { _tag: "UnsupportedFeature", feature, reason };
+}
+
+export function backendFailed(backend: BackendTag, message: string): RuntimeError {
+  return { _tag: "BackendFailed", backend, message };
+}
+
+export function commandFailed(args: RuntimeErrorArgs<"CommandFailed">): RuntimeError {
+  return { _tag: "CommandFailed", ...args };
+}
+
+export function structuredOutputValidationFailed(
+  args: RuntimeErrorArgs<"StructuredOutputValidationFailed">
+): RuntimeError {
+  return { _tag: "StructuredOutputValidationFailed", ...args };
+}
+
+export function ioFailed(seam: "source" | "sink" | "tool", kind: string, message: string): RuntimeError {
+  return { _tag: "IoFailed", seam, kind, message };
+}

package/src/model/index.ts

@@ -0,0 +1,7 @@
+export type * from "./backend-config.ts";
+export * from "./brand.ts";
+export * from "./errors.ts";
+export * from "./json-schema.ts";
+export * from "./result.ts";
+export * from "./schemas.ts";
+export * from "./structured.ts";

package/src/model/json-schema.ts

@@ -0,0 +1,14 @@
+import { z } from "zod";
+import { CanonicalSchemas } from "./schemas.ts";
+
+export function jsonSchemaFromZod(schema: z.ZodType): unknown {
+  return z.toJSONSchema(schema, { target: "draft-7" });
+}
+
+export function canonicalJsonSchemas(): Record<string, unknown> {
+  const schemas: Record<string, unknown> = {};
+  for (const [name, schema] of Object.entries(CanonicalSchemas)) {
+    schemas[name] = jsonSchemaFromZod(schema);
+  }
+  return schemas;
+}

package/src/model/result.ts

@@ -0,0 +1,28 @@
+import type { Result } from "neverthrow";
+
+export function orThrow<T, E>(result: Result<T, E>): T {
+  if (result.isOk()) {
+    return result.value;
+  }
+
+  const error = result.error;
+  if (error instanceof Error) {
+    throw error;
+  }
+  throw new Error(errorMessage(error), { cause: error });
+}
+
+function errorMessage(error: unknown): string {
+  if (
+    typeof error === "object" &&
+    error !== null &&
+    "_tag" in error &&
+    typeof error._tag === "string"
+  ) {
+    return error._tag;
+  }
+  if (typeof error === "string") {
+    return error;
+  }
+  return "Result failed";
+}