jorgex-stack 1.9.15 → 1.9.17

package/README.md

@@ -185,35 +185,13 @@ Usage:
 
 GitHub authentication: requests use `GH_TOKEN`/`GITHUB_TOKEN` from the environment or, if unavailable, the token from your `gh` CLI session (`gh auth token` — local read only, never logged or persisted). Without a token, GitHub limits parallel requests and some upstreams may appear as "offline".
 
-### OpenCode Goal Mode
+### OpenCode Goal Mode retirado
 
-The normal work-lifecycle already supports multi-PR plans: `work/{name}/PRD.md` and `plan.md` stay alive across intermediate merges, `work/{name}/pr/{NN}` stores each checkpoint, and `work/{name}/done` is reserved for the final close. Goal Mode is separate: an OpenCode plugin for long-running goals, multiple sessions, multiple slices, multiple worktrees, and, when needed, multiple PRs. It is not meant for short tasks. If the change fits without extended autonomy, do not use `/goal`.
+Goal Mode de OpenCode se ha retirado. Stack ya no instala su plugin ni el comando `/goal`; la continuidad de trabajo usa el lifecycle normal: `work/{name}/PRD.md` y `plan.md` permanecen durante los merges intermedios, `work/{name}/pr/{NN}` conserva cada checkpoint y `work/{name}/done` queda reservado para el cierre final.
 
-It only exists in OpenCode. Claude Code and Codex do not receive it.
+La retirada no migra el historial. `sync` sólo puede retirar archivos gestionados cuando dispone de un manifest legible que registre esas rutas como gestionadas y un inventario completo, con backup previo; conserva los datos existentes en `~/.jorgex-stack/goals` y los plugins ajenos cuando el manifest del Stack está íntegro. El registro local no autentica la propiedad ni corrige una lista `owned` editada o inconsistente: si falta, no se puede parsear o el inventario es incompleto, no se borra el legacy. Ante sospecha sobre el manifest, no ejecutes `sync`; revísalo o restáuralo con backup. `--target-dir` no implica limpiar ese estado.
 
-Available commands:
-
-- `/goal <goal>` — creates a persistent goal.
-- `/goal status` — shows status and next action.
-- `/goal plan` — shows the goal's master plan / PRD.
-- `/goal history` — lists events and transitions.
-- `/goal pause` — pauses the goal.
-- `/goal resume` — resumes the goal.
-- `/goal merged [commit]` — signals that the pending external PR has been merged.
-- `/goal cancel` — cancels the goal.
-
-What does not exist:
-
-- `/goal quick`
-- `/goal work`
-
-Operational state:
-
-- Separate SQLite database by default at `~/.jorgex-stack/goals/goals.sqlite`.
-- Optional override with `JORGEX_GOAL_DB`, but always inside `~/.jorgex-stack/goals/`.
-- Engram is not the goal's operational store: it remains memory/protocol, not the state database.
-- Goal Mode does not perform automatic merges; when it must wait for an external merge, the state becomes `waiting_for_merge`.
-- The integration uses experimental OpenCode hooks (`experimental.chat.system.transform` and `experimental.session.compacting`), so that surface may change.
+La continuidad entre checkpoints sigue requiriendo trabajo aprobado, capacidades disponibles y merge humano explícito. PiGoal conserva su propio lifecycle. No se afirma disponibilidad de una alternativa GoalV2 de OpenCode.
 
 ## Status
 
@@ -253,7 +231,7 @@ La integración de este App pertenece al release del repositorio Stack. No conce
 
 ## Development
 
-Requirements: Node >= 22.5 and pnpm (never npm). Goal Mode uses `node:sqlite` in tests/Node CLI and OpenCode uses `bun:sqlite` at runtime.
+Requirements: Node >= 22.5 and pnpm (never npm).
 
 ```
 pnpm install

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jorgex-stack",
-  "version": "1.9.15",
+  "version": "1.9.17",
   "description": "Harness multi-agente portable: instala la config JorgeX (agentes, skills, hooks, Engram, MCPs) en Claude Code, Codex CLI, OpenCode y Pi",
   "type": "module",
   "license": "MIT",

package/stack/skills/work-lifecycle/references/pr-continuation.md

@@ -24,4 +24,4 @@ Merge only on an explicit user order identifying the PR or intended batch, in a
 
 After reporting a ready checkpoint, continue only approved work that is safe and verifiable. Stop when that scope is exhausted, a material decision is missing, or available capabilities cannot execute the next safe work. Keep the work artifacts and report what is ready, what is blocked and why; do not call the overall roadmap complete merely because one PR is ready.
 
-**Current capability limit:** the bundled OpenCode Goal Mode records `waiting_for_merge` for an open PR, and its store/supervisor pause automatic continuation. This policy does not change that state machine. Do not bypass it or promise stacked automatic continuation in that mode; report the limitation and use only already-approved capabilities. Other runtimes also require their actual available Git/PR tools and permissions, not an assumed API.
+**Capability boundary:** each runtime requires its actual available Git/PR tools and permissions, not an assumed API or background supervisor. Report unavailable capabilities instead of bypassing them; this policy alone does not provide unattended execution or guarantee uninterrupted sessions.

package/stack/system-prompt/AGENTS.md

@@ -1,8 +1,5 @@
 ## Role
 
-### Developer Mode
-For code, architecture, bugs, infrastructure, and technical work.
-
 - Senior full-stack developer.
 - Prefer the simplest solution that works.
 - Verify before assuming.
@@ -11,18 +8,12 @@ For code, architecture, bugs, infrastructure, and technical work.
 
 Agents, skills, and MCPs are available. Use them whenever useful.
 
-### Assistant Mode
-For non-technical work: content, marketing, strategy, branding, copywriting, ideas, and analysis.
-
-- Be useful, direct, and opinionated.
-- No filler.
-
 ---
 
 ## Communication Style
 
 - Language: Spanish (Spain), natural and direct.
-- Keep answers short by default.
+- Be useful, direct, and opinionated. Keep answers short by default; no filler.
 - No emojis unless explicitly requested.
 - Do not repeat or paraphrase the user's message.
 - Point out problems clearly, without sugarcoating or dramatizing.
@@ -31,13 +22,7 @@ For non-technical work: content, marketing, strategy, branding, copywriting, ide
 
 ## General Behavior
 
-Be critical and analytical. Don't automatically say that something is "good" or "perfect." Evaluate each proposal by looking for:
-
-- Problems or limitations
-- Better alternatives
-- Missing or poorly defined aspects
-
-If you find errors, point them out directly. If there's a better approach, suggest it. Prioritize accuracy and usefulness over being nice.
+Be critical and analytical; don't automatically agree or praise proposals. Identify errors, limitations and missing or unclear aspects, and suggest better alternatives. Prioritize accuracy and usefulness over being nice.
 Ask questions when something isn't clear instead of assuming it's correct.
 
 - Work efficiently and modularly.
@@ -49,7 +34,6 @@ Ask questions when something isn't clear instead of assuming it's correct.
 - Make small, local, reviewable changes.
 - Reuse existing repo patterns before introducing new ones.
 - Do not add dependencies without explicit user approval.
-- Update affected docs when a change needs user or operational explanation, or makes existing claims incorrect; do not create prose for every internal edit.
 - Run lint and typecheck after significant changes when available.
 
 ---
@@ -116,8 +100,7 @@ Every piece of information about a piece of work has exactly ONE home — never
 - Use TDD for business rules, bugs/regressions, public contracts, and invariants. Do not impose it on styling, wiring, generated code, mechanical refactors, or trivial code unless they change meaningful behavior.
 - Prefer one authoritative test at the strongest seam closest to the risk. Add coverage at another layer only when it protects a distinct contract, not to repeat the same behavior.
 - Use the `tdd` skill for red-green-refactor, test-first work, or risk-based behavior testing.
-- Prefer targeted verification before broad suites.
-- Default order: specific test > partial suite > full suite.
+- Prefer targeted verification: specific test > partial suite > full suite.
 - Use the real test commands and test stack of the project.
 - For testing tasks, inspect the complete contract and the actual runner, command, scope, and environment; use existing tooling and neither auto-install nor impose Node, Vitest, pnpm, or another runner.
 - For CI tasks, act only when the scope requires it: measure comparable samples, use explicit refs, and when scope is uncertain run the relevant lane or fail closed; never cancel a mutable publication.
@@ -164,7 +147,7 @@ Detect the real environment before running commands; don't assume a shell or OS.
 
 ## Documentation
 
-- Keep documentation accurate for changed use, contracts and operations. Use the orchestrator's documentation rule to identify the needed surfaces and consolidate the specialist's pass; reopen only affected pages after later changes.
+- Update docs when changed use, contracts or operations need explanation or make existing claims incorrect, not for every internal edit. Use the orchestrator's documentation rule to identify the needed surfaces and consolidate the specialist's pass; reopen only affected pages after later changes.
 - Respect the separation between public and internal docs when it exists.
 - Keep content, navigation, and metadata in sync when docs are structured that way.
 - If docs are missing and needed, create the minimum useful documentation.

package/stack/commands/opencode/goal.md

@@ -1,7 +0,0 @@
----
-description: Goal Mode — manage persistent long-running objectives
----
-
-The Goal Mode plugin should handle `/goal $ARGUMENTS` before this prompt runs.
-
-If you are seeing this message as a normal assistant prompt, report that Goal Mode did not intercept the slash command. Do not start work, edit files, run tools, create branches, open PRs, or change repository state.

package/stack/plugins/opencode/goal/artifacts.ts

@@ -1,142 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import type { GoalStore } from "./types.js";
-
-export interface MasterArtifactsInput {
-  store: GoalStore;
-  goalId: string;
-  rootDir: string;
-  allowedRootDir?: string;
-}
-
-export interface MasterArtifactsResult {
-  created: boolean;
-  preserved: boolean;
-  prdPath: string;
-  planPath: string;
-}
-
-export function createMasterArtifacts(input: MasterArtifactsInput): MasterArtifactsResult {
-  const goal = input.store.getGoal(input.goalId);
-  if (!goal) {
-    throw new Error(`Goal ${input.goalId} not found.`);
-  }
-
-  const allowedRootDir = input.allowedRootDir ?? input.rootDir;
-  assertSafeArtifactPath(input.rootDir, allowedRootDir, "Goal artifact root");
-  fs.mkdirSync(input.rootDir, { recursive: true });
-
-  const prdPath = path.join(input.rootDir, "PRD.md");
-  const planPath = path.join(input.rootDir, "plan.md");
-  assertSafeArtifactPath(prdPath, allowedRootDir, "Goal PRD artifact");
-  assertSafeArtifactPath(planPath, allowedRootDir, "Goal plan artifact");
-  const prdCreated = writeIfMissing(prdPath, renderMasterPrd(goal.objective));
-  const planCreated = writeIfMissing(planPath, renderMasterPlan(goal.objective));
-
-  input.store.recordArtifact(goal.id, { kind: "prd", path: prdPath });
-  input.store.recordArtifact(goal.id, { kind: "plan", path: planPath });
-
-  return {
-    created: prdCreated || planCreated,
-    preserved: !prdCreated || !planCreated,
-    prdPath,
-    planPath,
-  };
-}
-
-export function assertSafeArtifactPath(filePath: string, allowedRootDir: string, label = "Goal artifact"): void {
-  const resolvedAllowedRoot = resolveExistingPathWithoutSymlinks(allowedRootDir, `${label} root`);
-  const resolvedPath = resolveExistingPathWithoutSymlinks(filePath, label);
-  if (!isContainedIn(resolvedPath, resolvedAllowedRoot)) {
-    throw new Error(`${label} must stay inside ${allowedRootDir}. Refusing: ${filePath}`);
-  }
-
-  const stats = lstatIfExists(filePath);
-  if (stats?.isFile() && stats.nlink > 1) {
-    throw new Error(`${label} must not be a hard link.`);
-  }
-}
-
-function writeIfMissing(filePath: string, content: string): boolean {
-  if (fs.existsSync(filePath)) return false;
-  fs.writeFileSync(filePath, content, "utf8");
-  return true;
-}
-
-function resolveExistingPathWithoutSymlinks(input: string, label: string): string {
-  assertNoSymlinkInExistingPath(input, label);
-  let current = path.resolve(input);
-  const missing: string[] = [];
-  while (!fs.existsSync(current)) {
-    missing.push(path.basename(current));
-    const parent = path.dirname(current);
-    if (parent === current) break;
-    current = parent;
-  }
-  const real = fs.existsSync(current) ? fs.realpathSync(current) : current;
-  return missing.reduceRight((base, part) => path.join(base, part), real);
-}
-
-function assertNoSymlinkInExistingPath(input: string, label: string): void {
-  const resolved = path.resolve(input);
-  const root = path.parse(resolved).root;
-  const relativeParts = path.relative(root, resolved).split(path.sep).filter(Boolean);
-  let current = root;
-  for (const part of relativeParts) {
-    current = path.join(current, part);
-    const stats = lstatIfExists(current);
-    if (!stats) return;
-    if (stats.isSymbolicLink()) {
-      throw new Error(`${label} must not include symlinks.`);
-    }
-  }
-}
-
-function lstatIfExists(input: string): fs.Stats | undefined {
-  try {
-    return fs.lstatSync(input);
-  } catch (error) {
-    if ((error as NodeJS.ErrnoException).code === "ENOENT") return undefined;
-    throw error;
-  }
-}
-
-function isContainedIn(candidate: string, root: string): boolean {
-  const relative = path.relative(root, candidate);
-  return relative === "" || (!!relative && !relative.startsWith("..") && !path.isAbsolute(relative));
-}
-
-function renderMasterPrd(objective: string): string {
-  return [
-    "# PRD maestro",
-    "",
-    "## Objetivo",
-    "",
-    objective,
-    "",
-    "## Alcance",
-    "",
-    "- Mantener el objetivo global del Goal Mode.",
-    "- Dividir el trabajo en slices ejecutables por el orquestador.",
-    "- Esperar merges manuales antes de continuar.",
-    "",
-  ].join("\n");
-}
-
-function renderMasterPlan(objective: string): string {
-  return [
-    "# Plan maestro",
-    "",
-    "## Objetivo",
-    "",
-    objective,
-    "",
-    "## Fases",
-    "",
-    "1. Preparar PRD/plan maestro.",
-    "2. Ejecutar slices acotados con el orquestador.",
-    "3. Procesar reviews y esperar merge externo cuando corresponda.",
-    "4. Verificar criterios globales antes de cerrar.",
-    "",
-  ].join("\n");
-}

package/stack/plugins/opencode/goal/command.ts

@@ -1,255 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import type { GoalRecord, GoalStatus, GoalStore, NextAction } from "./types.js";
-import { assertSafeArtifactPath, createMasterArtifacts } from "./artifacts.js";
-
-const COMMANDS = new Set(["status", "plan", "history", "pause", "resume", "cancel", "merged"]);
-const EXPLICITLY_UNSUPPORTED = new Set(["quick", "work"]);
-
-export interface GoalCommandHandlersOptions {
-  store: GoalStore;
-  project: string;
-  artifactsRootDir?: string;
-}
-
-export interface GoalCommandResponse {
-  message: string;
-}
-
-export interface GoalCommandHandlers {
-  handleGoalCommand(input: string): GoalCommandResponse;
-}
-
-export function createGoalCommandHandlers(options: GoalCommandHandlersOptions): GoalCommandHandlers {
-  let currentGoalId: string | undefined;
-
-  const currentGoal = () => {
-    const byId = currentGoalId ? options.store.getGoal(currentGoalId) : undefined;
-    const active = byId ?? options.store.getCurrentGoal(options.project);
-    currentGoalId = active?.id ?? currentGoalId;
-    return active;
-  };
-
-  const requireCurrentGoal = () => {
-    const goal = currentGoal();
-    if (!goal) {
-      throw new Error("No active goal found. Start one with /goal <objective>.");
-    }
-    return goal;
-  };
-
-  return {
-    handleGoalCommand(rawInput: string): GoalCommandResponse {
-      const input = rawInput.trim();
-      const [firstToken = "", ...args] = input.split(/\s+/);
-      const firstLower = firstToken.toLowerCase();
-      const normalized = firstLower === "merged" ? "merged" : input.toLowerCase();
-
-      if (input.length === 0) {
-        throw new Error("Goal objective cannot be empty.");
-      }
-
-      if (EXPLICITLY_UNSUPPORTED.has(normalized)) {
-        throw new Error("/goal quick and /goal work are not supported. Use /goal <objective> for large goals.");
-      }
-
-      if (!COMMANDS.has(normalized)) {
-        let artifactRootDir: string | undefined;
-        const goal = options.store.transaction(() => {
-          const createdGoal = options.store.createGoal({
-            objective: input,
-            project: options.project,
-          });
-          artifactRootDir = options.artifactsRootDir
-            ? path.join(options.artifactsRootDir, createdGoal.id)
-            : undefined;
-          try {
-            if (artifactRootDir) {
-              createMasterArtifacts({
-                store: options.store,
-                goalId: createdGoal.id,
-                rootDir: artifactRootDir,
-                allowedRootDir: options.artifactsRootDir,
-              });
-            }
-            options.store.appendEvent(createdGoal.id, {
-              type: "goal.created",
-              message: `Goal created: ${createdGoal.objective}`,
-              data: { objective: createdGoal.objective, project: createdGoal.project },
-            });
-          } catch (error) {
-            let cleanupFailure: string | undefined;
-            if (artifactRootDir && options.artifactsRootDir) {
-              cleanupFailure = cleanupBootstrappedArtifactDir(artifactRootDir, options.artifactsRootDir);
-            }
-            const rootCause = error instanceof Error ? error.message : String(error);
-            throw new Error(
-              `Goal bootstrap failed: ${rootCause}${cleanupFailure ? ` Cleanup also failed: ${cleanupFailure}` : ""}`,
-            );
-          }
-          return createdGoal;
-        });
-        currentGoalId = goal.id;
-
-        return {
-          message: `Goal created: ${goal.objective}\nStatus: ${goal.status}\nNext action: ${formatNextAction(options.store.nextAction(goal.id))}`,
-        };
-      }
-
-      if (normalized === "status") return statusResponse(currentGoal(), options.store);
-      if (normalized === "plan") {
-        return planResponse(requireCurrentGoal(), options.store, options.artifactsRootDir);
-      }
-      if (normalized === "history") return historyResponse(requireCurrentGoal(), options.store);
-
-      const goal = requireCurrentGoal();
-      if (normalized === "pause") {
-        return transitionResponse(options.store, goal, "paused", "Goal paused by user.");
-      }
-      if (normalized === "resume") {
-        if (goal.status === "waiting_for_merge") {
-          throw new Error("Cannot resume while the goal is waiting for an external PR merge.");
-        }
-
-        const nextStatus = options.store.getOpenPullRequest(goal.id) ? "waiting_for_merge" : "active";
-        return transitionResponse(options.store, goal, nextStatus, "Goal resumed by user.");
-      }
-      if (normalized === "cancel") {
-        return transitionResponse(options.store, goal, "cancelled", "Goal cancelled by user.");
-      }
-      if (normalized === "merged") {
-        return mergedResponse(options.store, goal, args.join(" "));
-      }
-
-      throw new Error(`Unsupported /goal command: ${input}`);
-    },
-  };
-}
-
-function statusResponse(goal: GoalRecord | undefined, store: GoalStore): GoalCommandResponse {
-  if (!goal) {
-    return { message: "No active goal. Start one with /goal <objective>." };
-  }
-
-  const lines = [
-      `Goal: ${goal.objective}`,
-      `Status: ${goal.status}`,
-      `Next action: ${formatNextAction(store.nextAction(goal.id))}`,
-    ];
-  const issue = latestAutoContinueIssue(store, goal.id);
-  if (issue) lines.push(`Operational issue: ${issue.message}`);
-
-  return {
-    message: lines.join("\n"),
-  };
-}
-
-function planResponse(goal: GoalRecord, store: GoalStore, artifactsRootDir: string | undefined): GoalCommandResponse {
-  const plan = store.getArtifact(goal.id, "plan");
-  if (plan) {
-    if (!fs.existsSync(plan.path)) {
-      throw new Error(`Registered goal plan is not readable at ${plan.path}. Recreate or fix the artifact path.`);
-    }
-    if (artifactsRootDir) {
-      assertSafeArtifactPath(plan.path, artifactsRootDir, "Registered goal plan");
-    }
-    return {
-      message: [`Plan for goal: ${goal.objective}`, fs.readFileSync(plan.path, "utf8")].join("\n\n"),
-    };
-  }
-
-  if (artifactsRootDir) {
-    throw new Error("Goal master plan artifact is not registered. Recreate or repair the goal artifacts.");
-  }
-
-  return {
-    message: [
-      `Plan for goal: ${goal.objective}`,
-      "Phases: master PRD/plan generation, slice execution, PR review, waiting for merge, final verification.",
-      "Detailed master artifacts are created by the next Goal Mode slice.",
-    ].join("\n"),
-  };
-}
-
-function cleanupBootstrappedArtifactDir(rootDir: string, allowedRootDir: string): string | undefined {
-  try {
-    assertSafeArtifactPath(rootDir, allowedRootDir, "Goal artifact cleanup path");
-    fs.rmSync(rootDir, { recursive: true, force: true });
-    return undefined;
-  } catch (error) {
-    return error instanceof Error ? error.message : String(error);
-  }
-}
-
-function mergedResponse(store: GoalStore, goal: GoalRecord, mergeCommit: string): GoalCommandResponse {
-  const pullRequest = store.getOpenPullRequest(goal.id);
-  if (!pullRequest) {
-    throw new Error("No open pull request is waiting for merge.");
-  }
-
-  const merged = store.recordPullRequestMerged(pullRequest.id, {
-    mergedAt: new Date().toISOString(),
-    mergeCommit: mergeCommit.trim() || "manual",
-  });
-
-  return {
-    message: `Pull request #${merged.number} marked as merged. Goal status: ${store.getGoal(goal.id)?.status ?? "unknown"}`,
-  };
-}
-
-function historyResponse(goal: GoalRecord, store: GoalStore): GoalCommandResponse {
-  const events = store.listEvents(goal.id);
-  const lines = events.length === 0
-    ? ["No history events recorded yet."]
-    : events.map((event) => `- ${event.createdAt} ${event.type}: ${event.message}`);
-
-  return {
-    message: [`History for goal: ${goal.objective}`, ...lines].join("\n"),
-  };
-}
-
-function transitionResponse(
-  store: GoalStore,
-  goal: GoalRecord,
-  status: GoalStatus,
-  reason: string,
-): GoalCommandResponse {
-  const updated = store.transitionGoal(goal.id, status, { reason });
-  return {
-    message: `Goal ${updated.status}: ${updated.objective}`,
-  };
-}
-
-function latestAutoContinueIssue(store: GoalStore, goalId: string) {
-  const events = store.listEvents(goalId);
-  const currentStateSequence = Math.max(
-    0,
-    ...events
-      .filter((event) => !event.type.startsWith("goal.auto_continue_"))
-      .map((event) => event.sequence),
-  );
-  return events
-    .filter((event) =>
-      (
-        event.type === "goal.auto_continue_unavailable" ||
-        event.type === "goal.auto_continue_failed" ||
-        event.type === "goal.auto_continue_skipped"
-      ) &&
-      readEventStateSequence(event.data) === currentStateSequence,
-    )
-    .at(-1);
-}
-
-function readEventStateSequence(data: unknown): number | undefined {
-  if (typeof data !== "object" || data === null || Array.isArray(data)) return undefined;
-  const value = (data as { stateSequence?: unknown }).stateSequence;
-  return typeof value === "number" ? value : undefined;
-}
-
-function formatNextAction(action: NextAction): string {
-  if (action.type === "wait_for_merge") {
-    return `waiting for external merge of ${action.pullRequestId}`;
-  }
-
-  return "continue";
-}

package/stack/plugins/opencode/goal/db.ts

@@ -1,68 +0,0 @@
-import path from "node:path";
-import fs from "node:fs";
-import { createRequire } from "node:module";
-
-type SqliteRow = Record<string, unknown>;
-
-interface SqliteStatement {
-  run(...params: unknown[]): unknown;
-  get(...params: unknown[]): SqliteRow | undefined;
-  all(...params: unknown[]): SqliteRow[];
-}
-
-interface SqliteDatabase {
-  exec(sql: string): void;
-  close(): void;
-  prepare?(sql: string): SqliteStatement;
-  query?(sql: string): SqliteStatement;
-}
-
-const require = createRequire(import.meta.url);
-
-function loadDatabaseCtor(): new (databasePath: string, options?: Record<string, unknown>) => SqliteDatabase {
-  if (typeof (globalThis as { Bun?: unknown }).Bun !== "undefined") {
-    return require("bun:sqlite").Database;
-  }
-
-  return require("node:sqlite").DatabaseSync;
-}
-
-export class GoalDb {
-  private readonly db: SqliteDatabase;
-
-  constructor(databasePath: string) {
-    fs.mkdirSync(path.dirname(databasePath), { recursive: true });
-    const Database = loadDatabaseCtor();
-    this.db = new Database(databasePath, { create: true });
-    this.exec("PRAGMA foreign_keys = ON;");
-    this.exec("PRAGMA busy_timeout = 5000;");
-  }
-
-  exec(sql: string): void {
-    this.db.exec(sql);
-  }
-
-  prepare(sql: string): SqliteStatement {
-    const statement = this.db.prepare?.(sql) ?? this.db.query?.(sql);
-    if (!statement) {
-      throw new Error("SQLite runtime does not expose prepare/query.");
-    }
-    return statement;
-  }
-
-  get(sql: string, ...params: unknown[]): SqliteRow | undefined {
-    return this.prepare(sql).get(...params);
-  }
-
-  all(sql: string, ...params: unknown[]): SqliteRow[] {
-    return this.prepare(sql).all(...params);
-  }
-
-  run(sql: string, ...params: unknown[]): unknown {
-    return this.prepare(sql).run(...params);
-  }
-
-  close(): void {
-    this.db.close();
-  }
-}