jorgex-stack 1.0.16 → 1.0.18

package/dist/cli.js

@@ -3003,7 +3003,8 @@ function parseFlags(args) {
     list: false,
     check: false,
     removeEngram: false,
-    positional: []
+    positional: [],
+    unknownFlags: []
   };
   const readValue = (index) => {
     const value = args[index + 1];
@@ -3039,6 +3040,7 @@ function parseFlags(args) {
     else if (arg === "--list") flags.list = true;
     else if (arg === "--check") flags.check = true;
     else if (arg === "--remove-engram") flags.removeEngram = true;
+    else if (arg.startsWith("-")) flags.unknownFlags.push(arg);
     else flags.positional.push(arg);
   }
   return flags;
@@ -3119,6 +3121,7 @@ function parseCliArgs(argv) {
   const flags = parseFlags(isCommand ? rest : argv);
   if (first === "--help" || first === "-h" || flags.help) return { action: "help", command, flags };
   if (first === "--version" || first === "-v" || flags.version) return { action: "version", command, flags };
+  if (flags.unknownFlags.length > 0) return { action: "unknown-flags", command, flags };
   return { action: "run", command, flags };
 }
 async function resolveRuntimes(flags) {
@@ -3172,6 +3175,18 @@ async function main() {
     process.exitCode = 1;
     return;
   }
+  if (parsed.action === "unknown-flags") {
+    const { unknownFlags } = parsed.flags;
+    const plural = unknownFlags.length > 1;
+    console.error(`Flag${plural ? "s" : ""} no reconocido${plural ? "s" : ""}: ${unknownFlags.join(", ")}`);
+    console.error(
+      `jorgex-stack v${VERSION} no reconoce ${plural ? "esos flags" : "ese flag"}. Si esperabas que existiera, puede que est\xE9s ejecutando un binario cacheado antiguo:
+  pnpm dlx jorgex-stack@latest ...
+Flags disponibles: jorgex-stack --help`
+    );
+    process.exitCode = 1;
+    return;
+  }
   const { command, flags } = parsed;
   if (flags.targetDir !== void 0 && flags.agents.length !== 1) {
     console.error("--target-dir requiere exactamente un runtime en --agents.");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jorgex-stack",
-  "version": "1.0.16",
+  "version": "1.0.18",
   "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",

package/stack/plugins/opencode/engram.ts

@@ -18,7 +18,7 @@ import type { Plugin } from "@opencode-ai/plugin"
 
 declare const Bun: {
   which?: (bin: string) => string | null
-  spawnSync: (args: string[]) => { exitCode: number; stdout?: { toString(): string } | string }
+  spawnSync: (args: string[], options?: Record<string, unknown>) => { exitCode: number; stdout?: { toString(): string } | string }
   spawn: (args: string[], options?: Record<string, unknown>) => unknown
   file: (path: string) => { exists: () => Promise<boolean> }
 }
@@ -102,7 +102,7 @@ async function isEngramRunning(): Promise<boolean> {
 function extractProjectName(directory: string): string {
   // Try git remote origin URL
   try {
-    const result = Bun.spawnSync(["git", "-C", directory, "remote", "get-url", "origin"])
+    const result = Bun.spawnSync(["git", "-C", directory, "remote", "get-url", "origin"], { stdout: "pipe", stderr: "ignore", stdin: "ignore" })
     if (result.exitCode === 0) {
       const url = result.stdout?.toString().trim()
       if (url) {
@@ -114,7 +114,7 @@ function extractProjectName(directory: string): string {
 
   // Fallback: git root directory name (works in worktrees)
   try {
-    const result = Bun.spawnSync(["git", "-C", directory, "rev-parse", "--show-toplevel"])
+    const result = Bun.spawnSync(["git", "-C", directory, "rev-parse", "--show-toplevel"], { stdout: "pipe", stderr: "ignore", stdin: "ignore" })
     if (result.exitCode === 0) {
       const root = result.stdout?.toString().trim()
       if (root) return root.split(/[\\/]/).pop() ?? "unknown"
@@ -140,11 +140,39 @@ function stripPrivateTags(str: string): string {
   return str.replace(/<private>[\s\S]*?<\/private>/gi, "[REDACTED]").trim()
 }
 
+/**
+ * Log errors and warnings to OpenCode's TUI log.
+ * Errors in hooks must not propagate to the plugin surface — they are silently
+ * swallowed here so the TUI does not crash. The error is visible only in OpenCode's
+ * log stream (visible to the user via `opencode logs`).
+ */
+async function logToOpenCode(client: unknown, level: string, message: string, extra?: unknown): Promise<void> {
+  if (typeof client !== "object" || client === null) return;
+  const app = (client as { app?: unknown }).app;
+  if (typeof app !== "object" || app === null) return;
+  const log = (app as { log?: unknown }).log;
+  if (typeof log !== "function") return;
+  const safeExtra = extra instanceof Error ? { message: extra.message, stack: extra.stack } : extra;
+  try {
+    await log.call(app, {
+      body: {
+        service: "engram",
+        level,
+        message,
+        extra: safeExtra,
+      },
+    });
+  } catch {
+    // Logging must never break the plugin path.
+  }
+}
+
 // ─── Plugin Export ───────────────────────────────────────────────────────────
 
 export const Engram: Plugin = async (ctx) => {
   const oldProject = ctx.directory.split(/[\\/]/).pop() ?? "unknown"
   const project = extractProjectName(ctx.directory)
+  const client = (ctx as { client?: unknown }).client
   const engramBin = resolveEngramBin()
 
   // Track tool counts per session (in-memory only, not critical)
@@ -228,10 +256,21 @@ export const Engram: Plugin = async (ctx) => {
     // Manifest doesn't exist or binary not found — silently skip
   }
 
+  // ─── Safe Hook Wrapper ─────────────────────────────────────────
+  // Wraps every hook to catch errors and log them to OpenCode instead
+  // of letting them propagate. This prevents malformed payloads or
+  // missing fields (output.context, output.system, etc.) from crashing
+  // the TUI. Errors are logged and swallowed (promise resolves cleanly).
+  const safe = <A extends unknown[]>(name: string, fn: (...args: A) => Promise<void>) =>
+    async (...args: A): Promise<void> => {
+      try { await fn(...args) }
+      catch (error) { void logToOpenCode(client, "error", `Engram hook ${name} failed`, error) }
+    }
+
   return {
     // ─── Event Listeners ───────────────────────────────────────────
 
-    event: async ({ event }: { event: { type: string; properties?: unknown } }) => {
+    event: safe("event", async ({ event }: { event: { type: string; properties?: unknown } }) => {
       // --- Session Created ---
       if (event.type === "session.created") {
         // Bug fix (#116): session data is nested under event.properties.info,
@@ -271,7 +310,7 @@ export const Engram: Plugin = async (ctx) => {
         }
       }
 
-    },
+    }),
 
     // ─── User Prompt Capture ──────────────────────────────────────
     // chat.message is called once per user message, before the LLM sees it.
@@ -279,7 +318,7 @@ export const Engram: Plugin = async (ctx) => {
     // output.message is typed as UserMessage (role:"user" already guaranteed).
     // output.parts contains TextPart[] with the actual message text.
 
-    "chat.message": async (input: any, output: any) => {
+    "chat.message": safe("chat.message", async (input: any, output: any) => {
       // Skip sub-agent sessions — they inflate session counts (issue #116)
       if (subAgentSessions.has(input.sessionID)) return
 
@@ -313,7 +352,7 @@ export const Engram: Plugin = async (ctx) => {
           })
         }
       }
-    },
+    }),
 
     // ─── Tool Execution Hook ─────────────────────────────────────
     // Count tool calls per session (for session end stats).
@@ -321,7 +360,7 @@ export const Engram: Plugin = async (ctx) => {
     // Passive capture: when a Task tool completes, POST its output to
     // the passive capture endpoint so the server extracts learnings.
 
-    "tool.execute.after": async (input: any, output: any) => {
+    "tool.execute.after": safe("tool.execute.after", async (input: any, output: any) => {
       if (ENGRAM_TOOLS.has(input.tool.toLowerCase())) return
 
       // input.sessionID comes from OpenCode — always available
@@ -347,7 +386,7 @@ export const Engram: Plugin = async (ctx) => {
           })
         }
       }
-    },
+    }),
 
     // ─── System Prompt: Always-on memory instructions ──────────
     // Injects MEMORY_INSTRUCTIONS into the system prompt of every message.
@@ -359,13 +398,13 @@ export const Engram: Plugin = async (ctx) => {
     // block at the beginning. By concatenating, we avoid adding extra system
     // messages that would break these models. See: GitHub issue #23.
 
-    "experimental.chat.system.transform": async (_input: any, output: any) => {
+    "experimental.chat.system.transform": safe("experimental.chat.system.transform", async (_input: any, output: any) => {
       if (output.system.length > 0) {
         output.system[output.system.length - 1] += "\n\n" + MEMORY_INSTRUCTIONS
       } else {
         output.system.push(MEMORY_INSTRUCTIONS)
       }
-    },
+    }),
 
     // ─── Compaction Hook: Persist memory + inject context ──────────
     // Compaction is triggered by the system (not the agent) when context
@@ -375,7 +414,7 @@ export const Engram: Plugin = async (ctx) => {
     // 2. Inject context from previous sessions into the compaction prompt
     // 3. Tell the compressor to remind the new agent to save memories
 
-    "experimental.session.compacting": async (input: any, output: any) => {
+    "experimental.session.compacting": safe("experimental.session.compacting", async (input: any, output: any) => {
       if (input.sessionID) {
         await ensureSession(input.sessionID)
       }
@@ -400,6 +439,6 @@ export const Engram: Plugin = async (ctx) => {
         `Do this BEFORE any other work. After that, delegate to the global engram subagent to recover only the relevant previous context."\n\n` +
         `This is NOT optional. Without this, everything done before compaction is lost from memory.`
       )
-    },
+    }),
   }
 }

package/stack/plugins/opencode/goal/opencode-hooks.ts

@@ -44,16 +44,31 @@ export function createOpenCodeGoalHooks(deps: OpenCodeGoalHooksDeps): OpenCodeGo
     project: deps.project,
   });
 
+  // ─── Safe Hook Wrapper ─────────────────────────────────────────
+  // Wraps every hook to catch errors and log them via the logger instead
+  // of letting them propagate. This prevents OpenCode from crashing when
+  // Goal Mode hooks encounter malformed payloads or internal errors.
+  // Errors are logged (if a logger is provided) and swallowed (promise
+  // resolves cleanly even on failure).
+  const safe = <A extends unknown[]>(name: string, fn: (...args: A) => Promise<void>) =>
+    async (...args: A): Promise<void> => {
+      try {
+        await fn(...args);
+      } catch (error) {
+        try { deps.logger?.error?.(`Goal Mode hook ${name} failed`, error); } catch {}
+      }
+    };
+
   return {
-    "command.execute.before": async (input, output) => {
+    "command.execute.before": safe("command.execute.before", async (input, output) => {
       const command = extractCommandName(input);
       if (command !== "goal") return;
 
       const response = commands.handleGoalCommand(extractCommandArguments(input));
       replaceGoalCommandPrompt(input, output, response.message);
-    },
+    }),
 
-    "experimental.chat.system.transform": async (_input, output) => {
+    "experimental.chat.system.transform": safe("experimental.chat.system.transform", async (_input, output) => {
       const block = supervisor.renderSystemContext();
       if (!block) return;
 
@@ -64,18 +79,18 @@ export function createOpenCodeGoalHooks(deps: OpenCodeGoalHooksDeps): OpenCodeGo
 
       const lastIndex = output.system.length - 1;
       output.system[lastIndex] = upsertMarkedBlock(output.system[lastIndex]!, block);
-    },
+    }),
 
-    "experimental.session.compacting": async (_input, output) => {
+    "experimental.session.compacting": safe("experimental.session.compacting", async (_input, output) => {
       const block = supervisor.renderSystemContext();
       if (!block) return;
 
       if (!output.context.some((entry) => entry.includes(GOAL_MODE_MARKER_START))) {
         output.context.push(block);
       }
-    },
+    }),
 
-    event: async ({ event }) => {
+    event: safe("event", async ({ event }) => {
       if (event.type !== "session.idle") return;
 
       const decision = supervisor.decide();
@@ -147,7 +162,7 @@ export function createOpenCodeGoalHooks(deps: OpenCodeGoalHooksDeps): OpenCodeGo
       } finally {
         autoContinueInFlight.delete(dedupeKey);
       }
-    },
+    }),
   };
 }
 

package/stack/plugins/opencode/goal-plugin.ts

@@ -4,7 +4,7 @@ import fs from "node:fs";
 import { execFileSync } from "node:child_process";
 import { createHash } from "node:crypto";
 import { createGoalStore } from "./goal/store.js";
-import { createOpenCodeGoalHooks } from "./goal/opencode-hooks.js";
+import { createOpenCodeGoalHooks, type OpenCodeGoalHooks } from "./goal/opencode-hooks.js";
 
 interface GoalPluginLogger {
   warn?: (message: string, details?: unknown) => void;
@@ -51,11 +51,12 @@ function parseRemoteProjectKey(remote: string): string | undefined {
   return genericMatch?.[1];
 }
 
-export const GoalModePlugin = async (ctx: { directory: string; client?: unknown }) => {
+export const GoalModePlugin = async (ctx: { directory: string; client?: unknown }): Promise<OpenCodeGoalHooks> => {
   const logger = createGoalPluginLogger(ctx.client);
-  const databasePath = resolveGoalDatabasePath(process.env.JORGEX_GOAL_DB);
-  const store = createGoalStore({ databasePath });
+  let store: ReturnType<typeof createGoalStore> | undefined;
   try {
+    const databasePath = resolveGoalDatabasePath(process.env.JORGEX_GOAL_DB);
+    store = createGoalStore({ databasePath });
     store.migrate();
     const project = resolveGoalProjectName(ctx.directory, logger);
 
@@ -67,20 +68,26 @@ export const GoalModePlugin = async (ctx: { directory: string; client?: unknown
       logger,
     });
   } catch (error) {
-    store.close();
-    throw error;
+    // If Goal Mode initialization fails (e.g., JORGEX_GOAL_DB points outside
+    // the allowed directory), log the error and return empty hooks. This
+    // prevents Goal Mode from crashing the entire plugin layer.
+    logger.error?.("Goal Mode failed to initialize; Goal hooks disabled.", error);
+    store?.close();
+    return {};
   }
 };
 
 function createGoalPluginLogger(client: unknown): GoalPluginLogger {
   return {
     warn: (message, details) => {
+      // Log to OpenCode only; console.warn is omitted to avoid log pollution
+      // in user terminals. All logs go through OpenCode's log stream.
       void logToOpenCode(client, "warn", message, details);
-      console.warn(message, details);
     },
     error: (message, details) => {
+      // Log to OpenCode only; console.error is omitted to avoid log pollution
+      // in user terminals. All logs go through OpenCode's log stream.
       void logToOpenCode(client, "error", message, details);
-      console.error(message, details);
     },
   };
 }
@@ -91,13 +98,14 @@ async function logToOpenCode(client: unknown, level: "warn" | "error", message:
   if (typeof app !== "object" || app === null) return;
   const log = (app as { log?: unknown }).log;
   if (typeof log !== "function") return;
+  const safeExtra = details instanceof Error ? { message: details.message, stack: details.stack } : details;
   try {
     await log.call(app, {
       body: {
         service: "goal-mode",
         level,
         message,
-        extra: details,
+        extra: safeExtra,
       },
     });
   } catch {

package/stack/plugins/opencode/worktree.ts

@@ -358,7 +358,8 @@ export const WorktreePlugin: Plugin = async ({ $, client, directory }) => {
 
         const branchName = `${config.branchPrefix || "feature/"}${worktreeName}`;
 
-        const gitRoot = await $`git rev-parse --show-toplevel`.text();
+        // .quiet() suppresses stderr to prevent noisy TUI logs from git calls
+        const gitRoot = await $`git rev-parse --show-toplevel`.quiet().text();
         const projectRoot = String(gitRoot).trim().replace(/\\/g, "/");
         const commandCwd = getCommandCwd(args, directory);
         const absoluteWorktreePath = resolvePath(commandCwd, parsedWorktreePath);