jorgex-stack 1.0.3 → 1.0.4

package/PRD.md

@@ -31,7 +31,7 @@ pnpm dlx jorgex-stack doctor   → verifica que todo está sano
 
 | # | Decisión | Elección |
 |---|----------|----------|
-| D1 | Tecnología del instalador | **TypeScript + Node (≥20)**, bundle único (tsup/esbuild), prompts con `@clack/prompts`, publicado en el registry npm y ejecutado con `pnpm dlx jorgex-stack`. Sin Go, sin binarios propios. |
+| D1 | Tecnología del instalador | **TypeScript + Node (≥22.5)**, bundle único (tsup/esbuild), prompts con `@clack/prompts`, publicado en el registry npm y ejecutado con `pnpm dlx jorgex-stack`. Sin Go, sin binarios propios. |
 | D2 | Plataformas | **Cross-platform desde v1** (Windows + macOS + Linux). Windows es el entorno principal de pruebas. |
 | D3 | Estrategia de despliegue | **Merge idempotente con marcadores** (`<!-- jorgex:seccion -->` en markdown, upsert quirúrgico en JSON/TOML). Backup automático antes de tocar nada + rollback. Nunca machaca contenido manual del usuario. |
 | D4 | Plugins de jorgex-custom-tools | Se **copian** al nuevo repo ahora (los originales NO se tocan porque están en uso). **Cuando el proyecto esté completo e instalado**: se eliminan de `C:\Users\jorge\Desktop\jorgex-custom-tools` y pasan a vivir/instalarse SOLO desde JorgeX Stack. Ver §11 F6. |
@@ -217,7 +217,7 @@ Solo dos MCPs en el stack (D5):
 El paquete `jorgex-stack` se publica solo, sin acción del usuario. El workflow `.github/workflows/publish.yml` corre en cada push a `main` y aplica esta política:
 
 1. **Detección de cambios publicables**: se compara `HEAD` contra `v<package.version>` si ese tag existe; si no, cae a `github.event.before`. Son publicables los de `src/`, `stack/` y la lista exacta (`upstreams.json`, `package.json`, `pnpm-lock.yaml`, `tsconfig.json`, `tsup.config.ts`, `README.md`, `PRD.md`). **No** son publicables los cambios solo en `work/`, `worktrees/`, tests, ni en archivos fuera de la lista. La política está modelada y testeada en `src/lib/release.ts` (`classifyReleasePaths`); el workflow la replica inline para no ejecutar código generado por el repo en el job privilegiado.
-2. **Patch automático + recuperación manual**: si hay cambios publicables y la versión de `package.json` ya existe en npm, el workflow busca el primer patch libre (`x+1`, `x+2`, …) con `bumpPatch` (`src/lib/release.ts`), commitea `chore(release): bump version to v…` con el actor `github-actions[bot]` y publica la nueva versión. `validate` resuelve una sola vez la SHA objetivo y la expone como `target_sha`; `bump` la reutiliza y solo falla verde en `stale_run` cuando una run de push quedó vieja tras `git fetch origin main --tags` y `origin/main` ya no coincide con la SHA validada. Un `workflow_dispatch` sobre `main` recupera una publicación fallida: si no se pasa `release_sha`, `validate` fija `target_sha` a `origin/main` tras el fetch; si se pasa, debe ser una SHA completa de 40 hex perteneciente a `main` y se valida su `package.json.version` antes de publicar o tagear. Si la `release_sha` no es válida o no pertenece a `main`, el job falla en rojo con mensaje accionable; `workflow_dispatch` nunca emite `skip_reason=stale_run`. Si no hay cambios publicables en un push normal: no hace nada.
+2. **Patch automático + recuperación manual**: si hay cambios publicables y la versión de `package.json` ya existe en npm, el workflow busca el primer patch libre (`x+1`, `x+2`, …) con `bumpPatch` (`src/lib/release.ts`), commitea `chore(release): bump version to v…` con el actor `github-actions[bot]` y publica la nueva versión. `validate` resuelve una sola vez la SHA objetivo y la expone como `target_sha`; `bump` la reutiliza y solo falla verde en `stale_run` cuando una run de push quedó vieja tras `git fetch origin main --tags` y `origin/main` ya no coincide con la SHA validada. Un `workflow_dispatch` sobre `main` recupera una publicación fallida: si no se pasa `release_sha`, `validate` fija `target_sha` a `origin/main` tras el fetch; si se pasa, debe ser una SHA completa de 40 hex perteneciente a `main` y se valida su `package.json.version` antes de publicar o tagear. Si la `release_sha` no es válida o no pertenece a `main`, el job falla en rojo con mensaje accionable; `workflow_dispatch` nunca emite `skip_reason=stale_run`. Si el diff mezcla cambios publicables con `.github/workflows/*`, el auto-release se aborta antes de bump/publish porque GitHub puede rechazar el push del tag sin permisos para workflows; hay que separar la release o usar una publicación/tag manual con permisos elevados. Si no hay un tag de release previo alcanzable para reconstruir el rango de recovery, el workflow falla cerrado y exige intervención manual. Si no hay cambios publicables en un push normal: no hace nada.
 3. **Minor y major manuales**: cuando el siguiente patch ya existe en npm (p.ej. el workflow detectó que `1.0.3` está ocupado), falla con mensaje claro y exige bump manual de `package.json` en un PR. Minor y major siguen siendo decisiones humanas.
 4. **Guarda anti-loop**: `isReleaseBumpCommit` reconoce solo `chore(release):`, semver puro (`1.0.3`, `v1.0.3`) y commits de actores que terminan en `[bot]` y mencionan release/publish/bump/version. `release:` genérico y `chore:` a secas no cuentan. Cuando detecta uno, no vuelve a bumpear ni a publicar.
 5. **OIDC / trusted publishing**: el job de bump/push usa solo `contents: write`; el job de publish usa `permissions: id-token: write` + `contents: read` y `setup-node` con `registry-url: https://registry.npmjs.org`; el `tag-release` solo usa `contents: write` y no necesita OIDC. **No** se usan `NPM_TOKEN` ni `NODE_AUTH_TOKEN` — los únicos secretos del repo son los de GitHub. La excepción a la regla D8 ("pnpm siempre") son `npm pack --dry-run --ignore-scripts` y el `npm publish --ignore-scripts --provenance` final: el cliente npm permite fijar `--ignore-scripts` y publicar con OIDC/provenance contra el registry oficial.

package/README.md

@@ -39,16 +39,46 @@ Uso:
 
 Autenticación con GitHub: las consultas usan `GH_TOKEN`/`GITHUB_TOKEN` del entorno o, si no existen, el token de tu sesión de `gh` CLI (`gh auth token` — solo lectura local, nunca se loguea ni persiste). Sin token, GitHub limita las consultas en paralelo y algunos upstreams pueden salir como "sin conexión".
 
+### Goal Mode de OpenCode
+
+Goal Mode es un plugin de OpenCode para objetivos largos: varias sesiones, varios slices, varios worktrees y, si hace falta, varios PRs. No está pensado para tareas cortas. Si el cambio cabe sin autonomía prolongada, no uses `/goal`.
+
+Solo vive en OpenCode. Claude Code y Codex no lo reciben.
+
+Comandos disponibles:
+
+- `/goal <objetivo>` — crea un goal persistente.
+- `/goal status` — muestra estado y siguiente acción.
+- `/goal plan` — enseña el plan maestro / PRD del goal.
+- `/goal history` — lista eventos y transiciones.
+- `/goal pause` — pausa el goal.
+- `/goal resume` — reanuda el goal.
+- `/goal merged [commit]` — señala que el PR externo pendiente ya se ha mergeado.
+- `/goal cancel` — cancela el goal.
+
+Lo que no existe:
+
+- `/goal quick`
+- `/goal work`
+
+Estado operativo:
+
+- SQLite separada por defecto en `~/.jorgex-stack/goals/goals.sqlite`.
+- Override opcional con `JORGEX_GOAL_DB`, pero siempre dentro de `~/.jorgex-stack/goals/`.
+- Engram no es el store operativo del goal: sigue siendo memoria/protocolo, no base de estado.
+- Goal Mode no hace merges automáticos; cuando toca esperar un merge externo, el estado pasa a `waiting_for_merge`.
+- La integración usa hooks experimentales de OpenCode (`experimental.chat.system.transform` y `experimental.session.compacting`), así que esa superficie puede cambiar.
+
 ## Estado
 
 CLI completo y migración real ejecutada (F6); el stack es la única fuente de configuración. Las versiones se publican automáticamente en [npm](https://www.npmjs.com/package/jorgex-stack) según el flujo descrito en [Publicación](#publicación). El diseño, las decisiones (D1–D9) y el roadmap están en [PRD.md](PRD.md).
 
 ## Publicación
 
-La release la dispara el push/merge a `main` y GitHub Actions; también hay `workflow_dispatch` de recuperación sobre `main` con `release_sha` opcional. `validate` resuelve una sola vez la SHA objetivo y la expone como `target_sha`; `bump` reutiliza esa SHA. Si no pasas `release_sha`, `validate` fija `target_sha` a `origin/main` tras `fetch`; si la pasas, debe ser una SHA completa de 40 hex perteneciente a `main` o falla en rojo con instrucción de recuperación. El modo sin `release_sha` solo es válido para publicar `origin/main` cuando la versión aún no existe en npm; si la versión ya existe y falta el tag, el workflow falla y exige `workflow_dispatch` con `release_sha=<sha publicada>`. No se usa `pnpm publish` ni hace falta login de npm:
+La release la dispara el push/merge a `main` y GitHub Actions; también hay `workflow_dispatch` de recuperación sobre `main` con `release_sha` opcional. `validate` resuelve una sola vez la SHA objetivo y la expone como `target_sha`; `bump` reutiliza esa SHA. Si no pasas `release_sha`, `validate` fija `target_sha` a `origin/main` tras `fetch`; si la pasas, debe ser una SHA completa de 40 hex perteneciente a `main` o falla en rojo con instrucción de recuperación. El modo sin `release_sha` solo es válido para publicar `origin/main` cuando la versión aún no existe en npm; si la versión ya existe y falta el tag, el workflow falla y exige `workflow_dispatch` con `release_sha=<sha publicada>`. Si el diff mezcla cambios publicables con `.github/workflows/*`, el auto-release se corta antes de bump/publish porque GitHub puede rechazar el push del tag sin permisos para workflows; hay que separar la release o usar un publish/tag manual con permisos elevados. No se usa `pnpm publish` ni hace falta login de npm:
 
 - **Patch automático**: si el push a `main` contiene cambios publicables y la versión actual de `package.json` ya está en npm, el workflow busca el primer patch libre (`x+1`, `x+2`, …), commitea `chore(release): bump version to v…` y publica. Si ya existe el tag `v<package.version>`, usa ese punto como base acumulada; si no, cae a `github.event.before`. Las runs obsoletas se abortan tras `git fetch origin main --tags` si `origin/main` ya no coincide con `GITHUB_SHA`.
-- **Recuperación manual**: una ejecución manual sobre `main` con `release_sha` publica esa SHA si todavía no existe en npm, sin volver a bumpear; si la versión ya está en npm pero falta el tag `v<version>`, el workflow falla y te obliga a relanzar con `release_sha=<sha publicada>` para no tagear `origin/main`. `release_sha` debe ser una SHA completa de 40 hex y pertenecer a `main`; refs mutables (`main`, tags, `main~1`) se rechazan. Si no pasas `release_sha`, `validate` resuelve `origin/main` una vez, lo expone como `target_sha` y `bump` usa esa SHA validada.
+- **Recuperación manual**: una ejecución manual sobre `main` con `release_sha` publica esa SHA si todavía no existe en npm, sin volver a bumpear; si la versión ya está en npm pero falta el tag `v<version>`, el workflow falla y te obliga a relanzar con `release_sha=<sha publicada>` para no tagear `origin/main`. `release_sha` debe ser una SHA completa de 40 hex y pertenecer a `main`; refs mutables (`main`, tags, `main~1`) se rechazan. Si no pasas `release_sha`, `validate` resuelve `origin/main` una vez, lo expone como `target_sha` y `bump` usa esa SHA validada. La recuperación no salta la guarda de `.github/workflows/*`: si el diff mezcla workflows con cambios publicables, hay que separar la release o hacer el tag/publish con permisos elevados. Si no existe un tag de release previo alcanzable para reconstruir el rango, el workflow falla cerrado y exige intervención manual.
 - **Sin release**: cambios solo en `work/`, `worktrees/`, tests o archivos no listados como publicables (`src/`, `stack/`, `upstreams.json`, `package.json`, `pnpm-lock.yaml`, `tsconfig.json`, `tsup.config.ts`, `README.md`, `PRD.md`) no generan release.
 - **Minor y major manuales**: bump explícito de `package.json` en el PR (el workflow detecta que el siguiente patch ya existe en npm y exige el bump).
 - **OIDC / trusted publishing**: el job de publicación usa `id-token: write` y `registry-url` de `setup-node`; el job de bump/push solo tiene `contents: write`; el `tag-release` solo escribe `contents` y no usa OIDC. No hay `NPM_TOKEN` ni `NODE_AUTH_TOKEN` en ningún secreto. El `tag-release` solo corre si `publish` fue `success` o `skipped` con `tag_needed=true` y conserva su validación SHA como última defensa. La única excepción a la regla "pnpm siempre" son `npm pack --dry-run --ignore-scripts` y `npm publish --ignore-scripts --provenance` en el paso final, por compatibilidad y hardening del registry.
@@ -57,7 +87,7 @@ Los detalles de diseño están en [PRD §7.6](PRD.md#76-publicación-automática
 
 ## Desarrollo
 
-Requisitos: Node ≥ 20 y pnpm (nunca npm).
+Requisitos: Node ≥ 22.5 y pnpm (nunca npm). Goal Mode usa `node:sqlite` en tests/CLI Node y OpenCode usa `bun:sqlite` en runtime.
 
 ```
 pnpm install

package/dist/cli.js

@@ -1271,9 +1271,8 @@ function planPlugins(adapter, ctx) {
   if (pluginsDir === null) return [];
   const source = path16.join(ctx.stackDir, "plugins", adapter.id);
   if (!fs10.existsSync(source)) return [];
-  return fs10.readdirSync(source).filter((f) => f.endsWith(".ts")).map((f) => {
-    const sourceFile = path16.join(source, f);
-    const target = path16.join(pluginsDir, f);
+  return listFilesRecursive(source).filter((f) => f.endsWith(".ts")).map((sourceFile) => {
+    const target = path16.join(pluginsDir, path16.relative(source, sourceFile));
     const raw = fs10.readFileSync(sourceFile, "utf8");
     let content = raw;
     if (content.includes('"{{ENGRAM_BIN}}"')) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jorgex-stack",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "description": "Harness multi-agente portable: instala la config JorgeX (agentes, skills, hooks, Engram, MCPs) en Claude Code, Codex CLI y OpenCode",
   "type": "module",
   "license": "MIT",
@@ -28,7 +28,7 @@
     "PRD.md"
   ],
   "engines": {
-    "node": ">=20"
+    "node": ">=22.5"
   },
   "packageManager": "pnpm@11.1.1",
   "scripts": {

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

@@ -0,0 +1,142 @@
+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

@@ -0,0 +1,255 @@
+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

@@ -0,0 +1,68 @@
+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();
+  }
+}