jorgex-stack 1.9.15 → 1.9.16

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.16",
   "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/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();
-  }
-}