jorgex-stack 1.9.14 → 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.14",
+  "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/orchestrator/SKILL.md

@@ -90,6 +90,12 @@ Use the work already performed and its existing evidence/checkpoint; do not laun
 
 Respect the active output contract. In programmatic mode, keep the strict final JSON and its existing keys/types: put changes and factual workflow feedback in `summary`, current limitations in `risks` and pending actions in `next_steps`, preserving PR metadata in allowed text fields. Do not add keys, a `ready` status value, Markdown fences or prose outside that final JSON. Intermediate progress uses the permitted channel rather than pretending to be another final response.
 
+### Continue after a ready checkpoint
+
+A verified ready PR is a checkpoint, not an automatic pause. Give the Ready handoff and continue approved remaining work that can be verified with the available capabilities and project rules. An unavailable publication, migration, deployment or material decision blocks its consumers, not unrelated approved work. Do not invent another task just to keep running, and never infer merge permission from plan approval.
+
+For multi-PR work or a dependency on an unmerged PR, read [PR continuation](../work-lifecycle/references/pr-continuation.md) relative to this skill directory before choosing the next base; if unavailable, report that boundary rather than guessing a dependent base. Keep parents ready and immutable; only a permitted child branch/worktree may advance. Stop when no approved safe work remains or a real capability/decision block prevents it. A runtime supervisor that pauses for an open PR remains a real constraint; this policy does not override its state machine or create background execution.
+
 ## Closing rule
 
 Do not declare work finished after analysis or planning alone: complete the routed execution or report the concrete blocker.

package/stack/skills/orchestrator/references/standard-workflow.md

@@ -10,7 +10,7 @@ INIT → EXPLORE → SPEC → PLAN → EXECUTE → VERIFY → SHIP → CLOSE
 
 ### Autonomy
 
-The human drives the flow UP TO the plan: the idea, the PRD review and the plan review are interactive. Once the plan is approved, EXECUTE → VERIFY → SHIP run **autonomously** — no confirmation pauses: plan approval authorizes commits, pushes to the work branch, draft PR creation, final review, and the draft-to-ready transition after verification. Task-critical uncertainty from a subagent is an operational blocker, not a pause in autonomy: answer from existing context first; only if the decision genuinely cannot be made from available context may you ask the user, then relaunch with explicit guidance. Control returns to the user at CLOSE. Merging the PR is NEVER yours: it always requires an explicit user order. For multi-PR work, each merge is a checkpoint; keep `work/{name}/PRD.md` and `plan.md` alive until the roadmap is finished. Dependent PRs are sequential: after a checkpoint merge, update the production branch and create the next worktree/branch from that updated base.
+The human drives the flow UP TO the plan: the idea, PRD and plan review are interactive. Once approved, EXECUTE → VERIFY → SHIP run **autonomously** within that scope: commits, work-branch pushes, draft PR creation, review and ready transitions are authorized, not merges. Resolve task-critical uncertainty from available context first; ask the user only for a genuinely unresolved material decision. CLOSE finishes the current checkpoint and follows [Continue after a ready checkpoint](../SKILL.md#continue-after-a-ready-checkpoint), not a mandatory pause while safe approved work remains. Every merge still requires an explicit user order. Keep `work/{name}/PRD.md` and `plan.md` until the roadmap is finished; choose production or a permitted parent base through the common continuation rule, never through an assumed need to wait for every merge.
 
 ## 1. INIT
 
@@ -155,7 +155,7 @@ An early review during EXECUTE is an **exception**, not a default phase. Use it
 
 ## 7. SHIP (automatic)
 
-When the plan is fully applied and VERIFY passes:
+When the current checkpoint's planned work is applied and VERIFY passes:
 
 1. Confirm the draft PR exists, the worktree is clean, and the draft head matches the local HEAD. Complete any necessary documentation under the common rule and inspect the consolidated final diff against the PR's real base; do not publish intermediate behavior with required documentation missing.
 2. Apply **Final review and PR lifecycle** in the entry [SKILL.md](../SKILL.md) and the project's review requirements. Reuse valid prior review evidence; choosing standard does not require another panel. Process the review findings by their three levels:
@@ -170,7 +170,7 @@ When the plan is fully applied and VERIFY passes:
 
 ## 8. CLOSE
 
-- STOP here and hand control back to the user only after configured Quality Gates pass for the latest commit, or after confirming that the project has no PR checks configured. Apply the common [Ready handoff](../SKILL.md#ready-handoff): preserve the PR metadata, summarize changes and observed workflow feedback, report valid findings applied vs deferred and whether manual testing is advisable. Do not claim merge, deployment or overall roadmap completion from a ready checkpoint.
+- After configured Quality Gates pass for the current candidate, or after confirming that none are configured, close this checkpoint with the common [Ready handoff](../SKILL.md#ready-handoff). Preserve metadata, summarize changes and observed feedback, and report valid findings applied vs deferred and whether manual testing is advisable. Then follow [Continue after a ready checkpoint](../SKILL.md#continue-after-a-ready-checkpoint): continue approved safe work, or explain the real blocker/end of scope. Do not claim merge, deployment or overall roadmap completion from ready.
 - NEVER merge the PR yourself — merge only on an explicit user order. After each intermediate merge: persist the checkpoint to `work/{name}/pr/{NN}`, update `plan.md`, and keep `work/{name}/` alive. After the final merge: persist the final outcome to memory, clean up `work/{name}/` and remove the worktree (see Work state).
 - If the repo has its own skill for the closing steps (release, deploy, git, cleanup), that skill takes precedence over the default behavior.
 

package/stack/skills/work-lifecycle/SKILL.md

@@ -46,11 +46,11 @@ Use this section only after routing selects formal SDD work, including work prom
 - Only a formal task with an assigned phase outcome saves it BEFORE its final report; its outcome topic_key must be distinct from the `Spec` reference. Never use `mem_save` or `mem_update` to write a result over the Spec observation or its topic_key, or overwrite a Markdown Spec with an outcome. If no separate outcome destination was assigned, return the result to the coordinator for routing. An inline microassignment returns its evidence to the parent and has no separate spec or phase outcome. This does not waive mandatory immediate saves for decisions or findings.
 - Task status lives ONLY in the task table: flip it (⬜ → ✅) with a surgical edit when the task closes. PR status/evidence lives ONLY in the PR roadmap table. Do not mirror task progress into memory, and do not re-read the whole plan after every task — it is already in context; re-read it on resume.
 - Success criteria live ONLY in the plan's `SC-*` list. Task-to-criterion coverage lives ONLY in the task table's `SC` column. Verification/merge evidence lives ONLY in the PR roadmap or checkpoint that observed it; cite the relevant SC IDs there instead of copying the criteria into the task spec source.
-- For multi-PR work, resume from the first PR/task not done in the roadmap/table. For single-PR work, the canonical name worktree/branch is enough and the roadmap collapses to one checkpoint.
+- For multi-PR work, resume from the next approved executable checkpoint in the roadmap using [PR continuation](references/pr-continuation.md) to resolve its base, dependencies and runtime capability, then select its first pending task. Hand off ready checkpoints without modifying them; awaiting merge alone does not make them the next execution target. For single-PR work, the canonical name worktree/branch is enough and the roadmap collapses to one checkpoint.
 
 ## Pull request lifecycle
 
-1. Start from the updated production branch in the canonical worktree/branch. Apply the shared PR-scope rule in [Worktree and PR lifecycle](../orchestrator/SKILL.md#worktree-and-pr-lifecycle); formal SDD does not define a separate size policy.
+1. Start independent work from updated production. For multi-PR work or a Git dependency, choose the verified base using [PR continuation](references/pr-continuation.md). Use the canonical worktree/branch and the shared PR-scope rule in [Worktree and PR lifecycle](../orchestrator/SKILL.md#worktree-and-pr-lifecycle); formal SDD does not define a separate size policy.
 2. Implement one coherent first slice, commit it, push the work branch, and open the PR immediately as draft with `gh pr create --draft`.
 3. Continue implementation, commits and pushes only while the PR is draft. Draft means the code can still change; ready means the current SHA is the candidate to merge.
 4. Before ready, complete every applicable preflight item: code, version bump, local tests, project quality command (`pnpm qa:quality` when defined), Vercel preview review when the project uses Vercel, final diff inspection, and full PR review.
@@ -58,7 +58,7 @@ Use this section only after routing selects formal SDD work, including work prom
 6. Never push to a ready PR. If it needs changes, first run `gh pr ready --undo <number>`, then modify and push while draft, repeat preflight and review revalidation, mark ready again, and wait for a fresh complete gate when checks are configured. Use [coverage revalidation](../xreview/SKILL.md#7-revalidate-coverage-and-stop), not an automatic repeated panel; preserve evidence only for still-valid contracts and integration assumptions, including the effective base.
 7. Merge only after explicit user approval. When PR checks are configured, their passing result must match the current candidate SHA.
 
-Dependent PRs are sequential: merge one checkpoint, update the production branch, then create the next worktree/branch from that updated base. Do not stack a dependent PR from an unmerged work branch unless the human explicitly chooses a stacked-PR strategy.
+Development order and merge order are distinct. A ready checkpoint does not block the next independent or permitted Git-stacked checkpoint; an unavailable external prerequisite can. Record the dependencies and merge order in the existing roadmap and follow the continuation reference. Preserve project opt-outs and real supervisor/capability limits, and never turn plan approval into merge authorization.
 
 ## HTML review view (on demand)
 
@@ -89,7 +89,7 @@ If the project manages work through an issue tracker, issues (`to-issues`) take
 
 1. Read `work/{name}/plan.md` — the board says what's done and what's pending, and its `Spec` column names each formal task's only source.
 2. Resolve the declared Spec following the Delegation handoff rule in Executing, including its binding-before-get and scoped lookup requirements. For Markdown, read the canonical absolute path established there; use `mem_context` for recent phase outcomes.
-3. Continue from the first task without ✅.
+3. Select the next approved executable checkpoint using [PR continuation](references/pr-continuation.md) for multi-PR work or a Git dependency, then continue its first pending task. Preserve ready checkpoints unchanged; stop only when no approved work can safely proceed.
 
 ## Closing
 

package/stack/skills/work-lifecycle/references/plan-template.md

@@ -45,12 +45,13 @@ Every formal task has exactly one recoverable `Spec` reference in the plan table
 > Full checkpoint history lives in Engram under `work/[name]/pr/[NN]`.
 > Every evidence entry cites the relevant `SC-*` criteria it proves and records the command/setup, scope, result and limits.
 > PR status advances: ⬜ Pending → 📝 Draft → 🔍 Reviewed → ⏳ Ready / gates when configured → ✅ Merged.
-> If a ready PR changes, return it to Draft with `gh pr ready --undo`, clear stale gate evidence, and repeat review plus configured gates for the new SHA. If no PR checks are configured, confirm that from project configuration and record their absence instead of blocking the merge. An empty `gh pr checks` result immediately after ready is not evidence that no checks are configured. Immediately before reporting or merging, compare `gh pr view --json headRefOid` with the recorded candidate SHA.
+> If a ready PR needs changes or retargeting, return it to Draft with `gh pr ready --undo`, revalidate affected review coverage and configured gates, and record the new candidate/base context. A changed base or integration context matters even with the same head SHA. If no PR checks are configured, confirm and record that fact; an empty `gh pr checks` immediately after ready does not prove absence. Recheck candidate and base context immediately before reporting or merging.
+> For multiple PRs, use this same roadmap to record base branch/SHA, parent PR or external prerequisite, merge order and the real blocker where applicable. Ready permits continuing approved safe work, not merging; see [PR continuation](pr-continuation.md). Preserve project restrictions and actual runtime capabilities.
 
-| PR | Scope | Branch | Worktree | Base | Status | Merge evidence |
-|----|-------|--------|----------|------|--------|----------------|
-| 01 | [scope] | [branch] | [worktree] | [base] | ⬜ | [evidence] |
-| 02 | [scope] | [branch] | [worktree] | [base] | ⬜ | [evidence] |
+| PR | Scope | Branch | Worktree | Base / prerequisite / merge order | Status / blocker | Merge evidence |
+|----|-------|--------|----------|-----------------------------------|------------------|----------------|
+| 01 | [scope] | [branch] | [worktree] | [base branch@SHA; dependency and order if relevant] | ⬜ | [evidence] |
+| 02 | [scope] | [branch] | [worktree] | [base branch@SHA; dependency and order if relevant] | ⬜ | [evidence] |
 
 > Intermediate PRs do not delete `work/[name]/`; only the final close does.
 

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

@@ -0,0 +1,27 @@
+# Continue approved work across PRs
+
+Read this reference for multi-PR work or dependencies on an unmerged PR. It uses the existing roadmap, worktrees and review evidence; it does not create another queue, registry or permission to merge.
+
+## Choose the next runnable checkpoint
+
+- **Independent work:** use updated production as the base when no unmerged diff is needed.
+- **Git dependency:** use a separate child branch/worktree from a verified stable parent candidate when project rules and available tools permit it. Target the child PR at that parent branch so its review shows its own change. Do not modify a ready parent to advance its child.
+- **External prerequisite:** verify the actual artifact, migrated database, deployment or decision the next contract needs. A missing prerequisite blocks that consumer, not another approved independent checkpoint. Do not classify all frontend work as independent or all database work as blocked.
+
+Record the selected branch/base SHA, parent PR or external prerequisite, merge order and any real blocker in the existing roadmap columns. Keep readiness and integration separate: a child may be ready for review against its parent without being ready to merge to production. Do not invent new work, dependencies or an arbitrary chain length just to keep going.
+
+## Preserve the chain and its evidence
+
+Keep ready parents immutable. If a parent changes, a base advances, or a PR is retargeted, inspect the actual base/head/merge-base and effective diff. The same head SHA does not prove that previous review or checks still cover the integration context.
+
+Before deliberately changing or retargeting a ready child, return it to draft. Use the project's authorized Git strategy, preserve unrelated edits, and revalidate the affected coverage under `xreview`, plus the applicable local checks and fresh gates. Do not rewrite parents, discard work or force shared history merely for convenience; ask before a history-changing operation that is not already authorized.
+
+After a parent merges, inspect the child's real target. Retarget it to the appropriate integration base when needed before any merge; never accidentally merge into an open parent or an abandoned branch. Hosting-provider auto-retarget behavior is conditional, not a guarantee: do not delete branches to force it. A retarget event alone is not evidence that CI reran; verify the configured triggers and complete the proper draft/ready gate cycle.
+
+## Approval and stopping conditions
+
+Merge only on an explicit user order identifying the PR or intended batch, in a dependency-safe order. Plan approval, a ready child, passing checks or permission to continue development never authorizes future merges. Recheck candidate and base context immediately before the merge.
+
+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.
+
+**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

@@ -130,7 +130,7 @@ Every piece of information about a piece of work has exactly ONE home — never
 - Commit per task or per bounded group of tasks — small, separate commits whose history maps to the work; never everything in one giant commit.
 - Never push code or behavior changes directly to production branches (main/master or the repo's protected/release branches): those always go through a work branch + PR. Pushing a work branch or a worktree branch is fine without asking.
 - Exception: TRIVIAL changes — docs, typos, content removal, config text with no behavior or code-logic impact — may be committed and pushed directly to the production branch. When in doubt about whether a change is trivial, it is not: use a PR.
-- Start each non-trivial PR from an updated production branch in its canonical worktree/branch, and keep one concrete objective per PR. Dependent PRs are sequential: merge the first, update the production branch, then create the next branch from it.
+- Start each non-trivial PR in its canonical worktree/branch from the verified base appropriate to its dependencies: updated production for independent work, or a permitted stable parent candidate for a Git dependency. Keep one concrete objective per PR and record base/SHA, parent or external prerequisite, and merge order in the existing plan. Ready does not by itself stop approved safe work; follow the orchestrator's continuation rule, respecting project restrictions and runtime capabilities. Parents ready remain immutable and every merge still requires explicit user approval.
 - After the first coherent commit, push the work branch and always open the PR as draft with `gh pr create --draft`. Creating and pushing the work branch and draft PR is fine without asking.
 - Keep the PR in draft while its code can still change. All subsequent commits and pushes happen while draft; never push to a ready PR.
 - Before ready, complete all applicable preflight work: code, version bump, local tests, the project's quality command (`pnpm qa:quality` when defined), Vercel preview review when the project uses Vercel, final diff inspection, and the full PR review. React Doctor is manual/local, not a GitHub Actions gate.

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";
-}