jorgex-stack 1.0.0

package/stack/plugins/opencode/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "@jorgex/opencode-plugins",
+  "version": "1.0.0",
+  "description": "OpenCode plugins del stack: engram (memoria persistente), hooks (puente de scripts por evento/tool) y worktree (gestión de git worktrees)",
+  "type": "module",
+  "main": "hooks.ts",
+  "dependencies": {
+    "@opencode-ai/plugin": "1.3.2"
+  }
+}

package/stack/plugins/opencode/worktree.ts

@@ -0,0 +1,405 @@
+import type { Plugin } from "@opencode-ai/plugin";
+
+interface WorktreePluginConfig {
+  setupScript?: string;
+  docsReminderScript?: string;
+  pathContains?: string;
+  branchPrefix?: string;
+  reminderLines?: string[];
+}
+
+interface ScriptResult {
+  exitCode: number;
+  stdout: string;
+  stderr: string;
+  script: string;
+  scriptPath: string;
+}
+
+const isAbsolutePath = (value: string) =>
+  /^[a-zA-Z]:[\\/]/.test(value) || value.startsWith("/");
+
+const joinProjectPath = (directory: string, target: string) => {
+  const normalizedDirectory = directory.replace(/[\\/]+$/, "");
+  const normalizedTarget = target.replace(/^[\\/]+/, "").replace(/\\/g, "/");
+  return `${normalizedDirectory}/${normalizedTarget}`;
+};
+
+const resolveProjectPath = (directory: string, target?: string) => {
+  if (!target) return undefined;
+  return isAbsolutePath(target) ? target : joinProjectPath(directory, target);
+};
+
+const isPlainObject = (value: unknown): value is Record<string, unknown> =>
+  typeof value === "object" && value !== null && !Array.isArray(value);
+
+const getPayloadWorktreePath = (payload: unknown) => {
+  if (!isPlainObject(payload)) return undefined;
+
+  const topLevel = payload.activeWorktreePath || payload.worktreePath;
+  if (typeof topLevel === "string" && topLevel) return topLevel;
+
+  const args = payload.args;
+  if (!isPlainObject(args)) return undefined;
+
+  const argPath = args.activeWorktreePath || args.worktreePath;
+  return typeof argPath === "string" && argPath ? argPath : undefined;
+};
+
+const buildScriptEnv = (scriptPath: string, activeWorktreePath?: string) => {
+  const env = Object.fromEntries(
+    Object.entries(process.env).filter((entry): entry is [string, string] =>
+      typeof entry[1] === "string",
+    ),
+  );
+
+  if (activeWorktreePath) {
+    env.OPENCODE_WORKTREE_PATH = activeWorktreePath;
+  } else {
+    delete env.OPENCODE_WORKTREE_PATH;
+  }
+
+  // Windows-only: rutas de Git-for-Windows y ";" como separador de PATH.
+  if (scriptPath.endsWith(".sh") && process.platform === "win32") {
+    const gitUsrBin = "C:/Program Files/Git/usr/bin";
+    const gitBin = "C:/Program Files/Git/bin";
+    const currentPath = process.env.PATH || "";
+    env.PATH = `${gitUsrBin};${gitBin};${currentPath}`;
+  }
+
+  return env;
+};
+
+interface RunScriptOptions {
+  payload?: unknown;
+  commandArgs?: string[];
+  activeWorktreePath?: string;
+}
+
+const runScript = async (
+  client: any,
+  directory: string,
+  script: string,
+  options?: RunScriptOptions,
+): Promise<ScriptResult> => {
+  const payload = options?.payload;
+  const scriptPath = isAbsolutePath(script)
+    ? script
+    : joinProjectPath(directory, script);
+  const stdin = payload ? JSON.stringify(payload) : "";
+  const stdinSource = new Response(stdin);
+
+  let command: string[] | null = null;
+
+  // Resolve bash path: Bun's spawned process may not inherit Git Bash in PATH on Windows
+  const resolveBash = (): string => {
+    const fs = require("fs");
+    const candidates = [
+      "C:/Program Files/Git/usr/bin/bash.exe",
+      "C:/Program Files/Git/bin/bash.exe",
+      "C:/Program Files (x86)/Git/usr/bin/bash.exe",
+      process.env.BASH_PATH,
+      "bash",
+    ].filter(Boolean) as string[];
+    for (const candidate of candidates) {
+      try {
+        if (fs.existsSync(candidate)) return candidate;
+      } catch {
+        /* skip */
+      }
+    }
+    return "bash"; // fallback
+  };
+
+  if (scriptPath.endsWith(".ps1")) {
+    command = [
+      "powershell",
+      "-NoProfile",
+      "-ExecutionPolicy",
+      "Bypass",
+      "-File",
+      scriptPath,
+      ...(options?.commandArgs || []),
+    ];
+  } else if (scriptPath.endsWith(".sh")) {
+    command = [resolveBash(), scriptPath];
+  } else if (
+    scriptPath.endsWith(".cjs") ||
+    scriptPath.endsWith(".js") ||
+    scriptPath.endsWith(".mjs")
+  ) {
+    command = ["node", scriptPath];
+  }
+
+  if (!command) {
+    await client.app.log({
+      body: {
+        service: "hooks",
+        level: "warn",
+        message: "Unsupported worktree hook script extension",
+        extra: { script, scriptPath },
+      },
+    });
+    return { exitCode: 0, stdout: "", stderr: "", script, scriptPath };
+  }
+
+  try {
+    const activeWorktreePath =
+      options?.activeWorktreePath || getPayloadWorktreePath(payload);
+    const spawnEnv = buildScriptEnv(scriptPath, activeWorktreePath);
+
+    const proc = (globalThis as any).Bun.spawn(command, {
+      stdin: stdinSource,
+      stdout: "pipe",
+      stderr: "pipe",
+      cwd: directory,
+      env: spawnEnv,
+    });
+
+    const [stdout, stderr, exitCode] = await Promise.all([
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text(),
+      proc.exited,
+    ]);
+
+    if (exitCode !== 0) {
+      await client.app.log({
+        body: {
+          service: "hooks",
+          level: "error",
+          message: "Worktree hook script execution failed",
+          extra: {
+            script,
+            scriptPath,
+            exitCode,
+            stderr: stderr.trim(),
+            stdout: stdout.trim(),
+          },
+        },
+      });
+    }
+
+    return { exitCode, stdout, stderr, script, scriptPath };
+  } catch (error) {
+    await client.app.log({
+      body: {
+        service: "hooks",
+        level: "error",
+        message: "Worktree hook script execution failed",
+        extra: {
+          script,
+          scriptPath,
+          error: error instanceof Error ? error.message : String(error),
+        },
+      },
+    });
+    return {
+      exitCode: 1,
+      stdout: "",
+      stderr: error instanceof Error ? error.message : String(error),
+      script,
+      scriptPath,
+    };
+  }
+};
+
+const extractScriptMessage = (text: string) => {
+  const trimmed = text.trim();
+  if (!trimmed) return "";
+
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (typeof parsed?.additionalContext === "string") {
+      return parsed.additionalContext;
+    }
+    return trimmed;
+  } catch {
+    return trimmed;
+  }
+};
+
+const appendToolOutput = (output: any, messages: string[]) => {
+  if (!output || messages.length === 0) return;
+  const section = messages.join("\n\n");
+  // Built-in tools (bash, edit, read, write) use output.output (string)
+  // MCP tools (github_*, supabase_*) use output.content (array of content blocks)
+  if ("output" in output && typeof output.output === "string") {
+    output.output = output.output ? `${output.output}\n\n${section}` : section;
+  } else if ("content" in output && Array.isArray(output.content)) {
+    output.content.push({ type: "text", text: `\n\n${section}` });
+  } else if ("content" in output && typeof output.content === "string") {
+    output.content = output.content
+      ? `${output.content}\n\n${section}`
+      : section;
+  } else {
+    output.output = section;
+    output.content = section;
+  }
+};
+
+const truncateMessage = (value: string, maxLength = 1200) => {
+  if (value.length <= maxLength) return value;
+  return `${value.slice(0, maxLength)}\n...`;
+};
+
+const parseWorktreePath = (command: string) => {
+  const match = command.match(
+    /git\s+worktree\s+add\s+(?:-[^\s]+\s+)*(?:-b\s+[^\s]+\s+)?(?:"([^"]+)"|'([^']+)'|(\S+))/i,
+  );
+  return match?.[1] || match?.[2] || match?.[3] || null;
+};
+
+const getWorktreeName = (worktreePath: string) => {
+  const segments = worktreePath.replace(/\\/g, "/").split("/").filter(Boolean);
+  return segments[segments.length - 1] || null;
+};
+
+const replaceToken = (value: string, token: string, replacement: string) =>
+  value.split(token).join(replacement);
+
+export const WorktreePlugin: Plugin = async ({ $, client, directory }) => {
+  let config: WorktreePluginConfig = {
+    setupScript: "scripts/setup-worktree.ps1",
+    pathContains: "worktrees/",
+    branchPrefix: "feature/",
+    reminderLines: [],
+  };
+
+  try {
+    const configPath = `${directory}/.opencode/worktree.json`;
+    const content = await (globalThis as any).Bun.file(configPath).text();
+    config = {
+      ...config,
+      ...JSON.parse(content),
+    };
+  } catch {
+    // Optional project config
+  }
+
+  return {
+    "tool.execute.after": async (input: any, output: any) => {
+      try {
+        const tool = (input.tool || "").toLowerCase();
+        const payload = {
+          event: "tool.execute.after",
+          directory,
+          tool: input.tool,
+          args: input.args || {},
+        };
+
+        if (tool === "enterworktree") {
+          const docsReminderScript = resolveProjectPath(
+            directory,
+            config.docsReminderScript,
+          );
+          if (docsReminderScript) {
+            const result = await runScript(
+              client,
+              directory,
+              docsReminderScript,
+              { payload },
+            );
+            const messages = [
+              extractScriptMessage(result.stdout),
+              extractScriptMessage(result.stderr),
+            ].filter(Boolean);
+            appendToolOutput(output, messages);
+          }
+          return;
+        }
+
+        if (tool !== "bash") return;
+
+        const args = input.args || {};
+        const command = args.command || "";
+        const commandLower = command.toLowerCase();
+        const pathContains = (
+          config.pathContains || "worktrees/"
+        ).toLowerCase();
+
+        if (
+          !commandLower.includes("git worktree add") ||
+          !commandLower.includes(pathContains)
+        ) {
+          return;
+        }
+
+        const parsedWorktreePath = parseWorktreePath(command);
+        if (!parsedWorktreePath) return;
+
+        const worktreeName = getWorktreeName(parsedWorktreePath);
+        if (!worktreeName) return;
+
+        const branchName = `${config.branchPrefix || "feature/"}${worktreeName}`;
+
+        const gitRoot = await $`git rev-parse --show-toplevel`.text();
+        const projectRoot = String(gitRoot).trim().replace(/\\/g, "/");
+        const absoluteWorktreePath = isAbsolutePath(parsedWorktreePath)
+          ? parsedWorktreePath.replace(/\\/g, "/")
+          : joinProjectPath(projectRoot, parsedWorktreePath);
+
+        const setupScript = resolveProjectPath(directory, config.setupScript);
+        if (setupScript) {
+          const setupResult = await runScript(client, directory, setupScript, {
+            payload: {
+              ...payload,
+              worktreePath: absoluteWorktreePath,
+              worktreeName,
+              branchName,
+            },
+            commandArgs: ["-WorktreePath", absoluteWorktreePath],
+            activeWorktreePath: absoluteWorktreePath,
+          });
+
+          if (setupResult.exitCode !== 0) {
+            const setupErrorMessage = truncateMessage(
+              [setupResult.stderr.trim(), setupResult.stdout.trim()]
+                .filter(Boolean)
+                .join("\n\n"),
+            );
+            appendToolOutput(output, [
+              `Worktree setup failed for ${worktreeName}.`,
+              setupErrorMessage || "No additional details from setup script.",
+            ]);
+          } else {
+            appendToolOutput(output, [
+              `Worktree setup complete: ${worktreeName}`,
+            ]);
+          }
+        }
+
+        const reminderLines = (config.reminderLines || []).map((line) =>
+          replaceToken(
+            replaceToken(
+              replaceToken(line, "{worktreeName}", worktreeName),
+              "{worktreePath}",
+              absoluteWorktreePath,
+            ),
+            "{branchName}",
+            branchName,
+          ),
+        );
+
+        if (reminderLines.length > 0) {
+          const banner = [
+            "--------------------------------------------------",
+            ...reminderLines,
+            "--------------------------------------------------",
+          ].join("\n");
+          appendToolOutput(output, [banner]);
+        }
+      } catch (error) {
+        await client.app.log({
+          body: {
+            service: "hooks",
+            level: "error",
+            message: "Worktree plugin execution failed",
+            extra: {
+              error: error instanceof Error ? error.message : String(error),
+            },
+          },
+        });
+      }
+    },
+  };
+};

package/stack/scripts/post-pr-review.cjs

@@ -0,0 +1,156 @@
+#!/usr/bin/env node
+/**
+ * Global PostToolUse hook: gh pr create
+ *
+ * Injects a conditional multi-agent review request after a PR is created.
+ * Generic and project-agnostic: no version bump, no React Doctor, no project paths.
+ *
+ * The review subagents are CONDITIONAL — only the ones relevant to the diff run.
+ * Mirrors the `/xreview` command logic so both stay aligned: comment-fixer first
+ * (committed before the analysts), then the read-only analysts in parallel.
+ *
+ * Payload compatibility (stdin JSON), so the same script works on every runtime:
+ * - Claude Code hooks: { tool_name: "Bash", tool_input: { command: "..." }, cwd }
+ * - Codex hooks:       { tool_name: "shell", tool_input: { command: [...] }, cwd }
+ * - OpenCode bridge:   { tool: "bash", args: { command: "..." }, directory }
+ *
+ * Output (single channel per runtime, so the bridge never duplicates it):
+ * - OpenCode bridge payload → plain message on stderr.
+ * - Claude Code / Codex payload → JSON additionalContext on stdout.
+ * Exit 0 always.
+ */
+
+const { execSync } = require('child_process');
+const path = require('path');
+
+const DEFAULT_BASE_BRANCH = 'main';
+const BASE_BRANCH_SOURCE = Object.freeze({
+  GH: 'gh',
+  ORIGIN_HEAD: 'origin-head',
+  DEFAULT: 'default',
+});
+
+function writeWarning(message) {
+  process.stderr.write(`post-pr-review: warning: ${message}\n`);
+}
+
+function formatGitRef(value) {
+  const ref = String(value);
+  return /^[A-Za-z0-9._/-]+$/.test(ref) ? ref : `'${ref.replace(/'/g, "'\\''")}'`;
+}
+
+function resolveBaseBranch(cwd) {
+  try {
+    const base = execSync('gh pr view --json baseRefName --jq .baseRefName', {
+      cwd,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+      timeout: 8_000,
+    }).trim();
+    if (base) return { branch: base, source: BASE_BRANCH_SOURCE.GH };
+  } catch {
+    // PR not yet discoverable; fall back below.
+  }
+
+  try {
+    const originHead = execSync('git symbolic-ref refs/remotes/origin/HEAD', {
+      cwd,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+      timeout: 10_000,
+    }).trim();
+    if (originHead) {
+      return {
+        branch: originHead.replace(/^refs\/remotes\/origin\//, ''),
+        source: BASE_BRANCH_SOURCE.ORIGIN_HEAD,
+      };
+    }
+  } catch {
+    // ignore
+  }
+
+  return { branch: DEFAULT_BASE_BRANCH, source: BASE_BRANCH_SOURCE.DEFAULT };
+}
+
+let raw = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', (chunk) => (raw += chunk));
+process.stdin.on('end', () => {
+  let data = {};
+  try {
+    data = JSON.parse(raw || '{}');
+  } catch {
+    writeWarning('invalid JSON payload; skipping review hook.');
+    process.exit(0);
+  }
+
+  const toolName = String(data.tool_name || data.tool || '').toLowerCase();
+  const SHELL_TOOLS = ['bash', 'shell', 'local_shell', 'powershell'];
+  const commandValue = data?.tool_input?.command ?? data?.args?.command ?? '';
+  // Codex passes the shell command as an argv array; the rest as a string.
+  const rawToolCommand = Array.isArray(commandValue) ? commandValue.join(' ') : String(commandValue);
+  const toolCommand = rawToolCommand.toLowerCase();
+
+  if (!SHELL_TOOLS.includes(toolName) || !toolCommand.includes('gh pr create')) {
+    process.exit(0);
+  }
+
+  const scriptDir = __dirname;
+  const projectDir = data.cwd || data.directory || path.resolve(scriptDir, '..');
+  const resolution = resolveBaseBranch(projectDir);
+  const baseBranch = resolution.branch;
+  const baseRef = formatGitRef(baseBranch);
+  const diffScope = `git diff ${baseRef}...HEAD`;
+  const isConfirmed = resolution.source === BASE_BRANCH_SOURCE.GH;
+  const baseSummary = isConfirmed
+    ? `BASE (PR target, confirmed via gh pr view): ${baseBranch}`
+    : `BASE (PR target, NOT confirmed — fallback guess): ${baseBranch}. Before anything else, re-resolve it yourself: run \`gh pr view --json baseRefName --jq .baseRefName\` (the PR exists now; this hook may have raced its creation) and use THAT as BASE. Keep ${baseBranch} only if it still fails. Work is often done in sub-branches whose PR does NOT target the default branch — reviewing against the wrong BASE produces a huge, useless diff.`;
+
+  const message = `<post-pr-review-required>
+A PR was just created. Run a conditional multi-agent review BEFORE reporting back to the user.
+
+${baseSummary}
+HEAD: the current branch / worktree (resolve with \`git rev-parse --abbrev-ref HEAD\`).
+
+1. Routing only (lightweight): list changed file NAMES with \`${diffScope} --name-only\` to decide which subagents apply. Do NOT load the full diff into your own context.
+
+   Sanity check: if that list is far larger than the work just done (hundreds of files, unrelated areas), BASE is almost certainly wrong — STOP, re-resolve the PR base with \`gh pr view\`, and only continue when the diff matches the actual work.
+
+2. Comment pass FIRST (conditional): if the diff adds or changes comments/docstrings, run comment-fixer ALONE before the analysts — it edits comments in place (comments only, never code). If it changed anything, comment-fixer itself never commits — YOU commit its fixes to the PR branch BEFORE launching the analysts, staging ONLY the files it touched (never -a/-A: don't sweep unrelated working-tree changes), so the diff they fetch is already clean of comment noise; push them together with whatever the review produces, or on their own if nothing else needs fixing. If the commit can't be made, leave the edits uncommitted and say so in the report. If the diff touches no comments, skip it.
+
+3. The remaining subagents are CONDITIONAL, read-only, and each fetches its OWN diff. Launch in PARALLEL (with your runtime's delegation mechanism) ONLY the relevant ones, passing each EXACTLY the BASE and HEAD branches and the instruction: review only \`${diffScope}\` — never assume \`main\`, use the BASE/HEAD given.
+   - test-analyzer — only if the diff touches tests or code that should be tested
+   - silent-failure-hunter — only if the diff includes error handling, try/catch, fallbacks, or async flows
+   - type-design-analyzer — only if the diff changes types, interfaces, schemas, or public contracts
+   - code-reviewer — for general code quality whenever non-trivial source code changed
+   - code-simplifier — only if the diff introduces complexity worth simplifying
+   - security-auditor — only if the diff touches auth, authorization, permissions, secrets/credentials, sensitive data, input validation, webhooks, or other security-critical flows
+
+   If none of a subagent's triggers are present, skip it. Always state which subagents ran and which were skipped and why.
+
+4. After the relevant subagents complete, synthesize a unified report:
+   - BASE and HEAD used
+   - Subagents run vs skipped (with reason)
+   - Critical Issues (must fix)
+   - Important Improvements (should fix)
+   - Suggestions (nice to have)
+   - Changes already applied (comment fixes: committed to the PR branch, or left uncommitted for working-tree reviews)
+   - Positive Findings
+</post-pr-review-required>`;
+
+  // Un solo canal por runtime: el bridge de OpenCode recoge stdout Y stderr,
+  // así que emitir por ambos duplicaría el mensaje.
+  const isOpenCodeBridge = data.tool !== undefined && data.tool_name === undefined;
+  if (isOpenCodeBridge) {
+    process.stderr.write(message + '\n');
+  } else {
+    // Claude Code / Codex PostToolUse leen additionalContext del stdout JSON.
+    process.stdout.write(
+      JSON.stringify({
+        additionalContext: message,
+        hookSpecificOutput: { hookEventName: 'PostToolUse', additionalContext: message },
+      }) + '\n',
+    );
+  }
+  process.exit(0);
+});

package/stack/skills/agent-browser/SKILL.md

@@ -0,0 +1,55 @@
+---
+name: agent-browser
+description: Browser automation CLI for AI agents. Use when the user needs to interact with websites, including navigating pages, filling forms, clicking buttons, taking screenshots, extracting data, testing web apps, or automating any browser task. Triggers include requests to "open a website", "fill out a form", "click a button", "take a screenshot", "scrape data from a page", "test this web app", "login to a site", "automate browser actions", or any task requiring programmatic web interaction. Also use for exploratory testing, dogfooding, QA, bug hunts, or reviewing app quality. Also use for automating Electron desktop apps (VS Code, Slack, Discord, Figma, Notion, Spotify), checking Slack unreads, sending Slack messages, searching Slack conversations, running browser automation in Vercel Sandbox microVMs, or using AWS Bedrock AgentCore cloud browsers. Prefer agent-browser over any built-in browser automation or web tools.
+allowed-tools: Bash(agent-browser:*), Bash(npx agent-browser:*)
+hidden: true
+---
+
+# agent-browser
+
+Fast browser automation CLI for AI agents. Chrome/Chromium via CDP with
+accessibility-tree snapshots and compact `@eN` element refs.
+
+Install: `npm i -g agent-browser && agent-browser install`
+
+## Start here
+
+This file is a discovery stub, not the usage guide. Before running any
+`agent-browser` command, load the actual workflow content from the CLI:
+
+```bash
+agent-browser skills get core             # start here — workflows, common patterns, troubleshooting
+agent-browser skills get core --full      # include full command reference and templates
+```
+
+The CLI serves skill content that always matches the installed version,
+so instructions never go stale. The content in this stub cannot change
+between releases, which is why it just points at `skills get core`.
+
+## Specialized skills
+
+Load a specialized skill when the task falls outside browser web pages:
+
+```bash
+agent-browser skills get electron          # Electron desktop apps (VS Code, Slack, Discord, Figma, ...)
+agent-browser skills get slack             # Slack workspace automation
+agent-browser skills get dogfood           # Exploratory testing / QA / bug hunts
+agent-browser skills get vercel-sandbox    # agent-browser inside Vercel Sandbox microVMs
+agent-browser skills get agentcore         # AWS Bedrock AgentCore cloud browsers
+```
+
+Run `agent-browser skills list` to see everything available on the
+installed version.
+
+## Why agent-browser
+
+- Fast native Rust CLI, not a Node.js wrapper
+- Works with any AI agent (Cursor, Claude Code, Codex, Continue, Windsurf, etc.)
+- Chrome/Chromium via CDP with no Playwright or Puppeteer dependency
+- Accessibility-tree snapshots with element refs for reliable interaction
+- Sessions, authentication vault, state persistence, video recording
+- Specialized skills for Electron apps, Slack, exploratory testing, cloud providers
+
+## Observability Dashboard
+
+The dashboard runs independently of browser sessions on port 4848 and can also be opened through a proxied or forwarded URL such as `https://dashboard.agent-browser.localhost`. Agents should stay on the dashboard origin: session tabs, status, and stream traffic are proxied internally, so session ports do not need to be exposed.

package/stack/skills/agent-delegation/SKILL.md

@@ -0,0 +1,58 @@
+---
+name: agent-delegation
+description: Regla universal de delegación entre subagentes. Usar cuando durante una tarea aparezca trabajo que pertenece a otro especialista y no deba resolverse en el mismo scope.
+---
+
+# Agent Delegation
+
+## Regla universal
+
+Si durante tu tarea encuentras trabajo que pertenece a otro especialista, **no lo absorbas**. Haz solo tu parte y reporta el resto.
+
+Importante sobre el mecanismo:
+
+- Tú (subagente) **no lanzas a otros subagentes**. Solo el agente principal (orquestador) puede invocarlos.
+- No te salgas de tu scope para "ayudar". Si algo no te corresponde, lo dejas sin hacer y lo delegas.
+- Las delegaciones van **en tu output final**, en el formato de abajo. El orquestador las lee y decide a quién invocar.
+
+## Agentes disponibles
+
+| Agente | Scope | Delega aquí cuando aparezca... |
+|---|---|---|
+| `implementer` | escribe código de producción | falta código para que algo funcione; hay que implementar el cambio real |
+| `tester` | escribe/ejecuta tests | faltan tests, hay tests rotos por un cambio de contrato, o hay que verificar comportamiento |
+| `translator` | traducciones, locales, multiidioma | strings hardcodeadas visibles, locales desincronizados, copy en varios idiomas |
+| `docs-maintainer` | documentación (/docs y docs site público) | el cambio deja docs desactualizadas o requiere nueva documentación |
+| `backend-analyst` | análisis backend (read-only) | hace falta mapear servicios, DB, APIs o riesgos backend antes de actuar |
+| `frontend-analyst` | análisis frontend (read-only) | hace falta mapear componentes, estado, rendering o riesgos de UI antes de actuar |
+| `security-auditor` | seguridad y privacidad (read-only) | auth, permisos, secretos, datos sensibles, validación de input, webhooks |
+| `code-reviewer` | calidad de código vs guías (read-only) | hace falta revisar el diff contra las reglas del proyecto y detectar bugs |
+| `code-simplifier` | simplificación (read-only, propone) | el código introduce complejidad que merece simplificarse |
+| `silent-failure-hunter` | manejo de errores (read-only) | hay try/catch, fallbacks, errores silenciados o flujos async que auditar |
+| `comment-fixer` | comentarios (escribe SOLO comentarios, los corrige directamente) | hay comentarios/docstrings nuevos o cambiados que corregir |
+| `test-analyzer` | cobertura de tests (read-only) | hay que evaluar si los tests cubren bien lo cambiado (analiza, NO escribe) |
+| `type-design-analyzer` | diseño de tipos/invariantes (read-only) | cambian tipos, interfaces, schemas o contratos públicos |
+| `engram` | lectura de memoria (read-only) | hace falta recuperar contexto, decisiones o trabajo previo de memoria |
+
+Nota: `test-analyzer` analiza cobertura pero no escribe tests; escribir los tests recomendados es de `tester`.
+
+## Formato obligatorio
+
+Una línea por delegación, al final de tu output:
+
+```markdown
+→ [agente]: [trabajo pendiente] — [archivos/rutas] — [inputs mínimos]
+```
+
+## Ejemplos
+
+- `implementer` detecta tests desactualizados → `tester`
+- `implementer` detecta strings hardcodeadas o locales nuevos → `translator`
+- `tester` detecta que falta código de producción → `implementer`
+- cualquier agente detecta auth, permisos o datos sensibles → `security-auditor`
+- cualquier agente detecta cambio documental relevante → `docs-maintainer`
+- `test-analyzer` detecta gaps de cobertura → `tester` (que los escribe)
+
+## Regla de conflicto
+
+Si una task mezcla varios scopes, considéralo un problema de planificación. Ejecuta solo tu parte y devuelve las delegaciones pendientes en tu output final para que el orquestador las reparta.