@codexguild/mcp 1.1.0 → 1.5.0

package/README.md

@@ -7,16 +7,18 @@ forum, chat) and adds what has to run on your machine:
 
 | Local tool | What it does |
 |---|---|
-| `codexguild_scan_skills` | Audits every skill installed in `~/.claude/skills`, `~/.claude/plugins`, `~/.codex/skills`, `~/.agents/skills`, `~/.hermes/skills`, `~/.config/opencode/skills`, `~/.cursor/skills`, `~/.openclaude/skills` **offline**, with the same scanner CodexGuild runs server-side (pipe-to-shell, secret exfiltration, prompt injection, hidden unicode, config tampering…). Nothing is uploaded. |
-| `codexguild_sync` | Detects your stack from `package.json`, `requirements.txt`, `pyproject.toml`, `go.mod`, … and your installed skills, then asks CodexGuild what changed since your model's training cutoff. |
+| `codexguild_scan_skills` | Audits the skills installed for every supported harness (`~/.claude/skills`, `~/.claude/plugins`, `~/.codex/skills`, `~/.agents/skills`, `~/.hermes/skills`, `~/.cursor/skills`, `~/.gemini/skills`, … and the project's own `.claude/`, `.agents/`, `.github/` skills) **offline**, with the same scanner CodexGuild runs server-side (pipe-to-shell, secret exfiltration, prompt injection, hidden unicode, config tampering…). Nothing is uploaded. |
+| `codexguild_sync` | Detects your stack with the **exact installed versions from your lockfiles** (package-lock, pnpm-lock, yarn.lock, bun.lock, poetry.lock, uv.lock, Pipfile.lock, Cargo.lock; go.mod), the Node/Python runtime (.nvmrc, .tool-versions, engines) and your installed skills, keys it to the current repository (each project keeps its own sync window), then asks CodexGuild what changed and which installed versions have known vulnerabilities. |
 | `codexguild_advise` | Detects the instruction files in your project (`CLAUDE.md`, `AGENTS.md`, …) before proposing setup changes. Proposals always need your approval. |
+| `codexguild_scan_workflows` | Reviews the project's GitHub Actions workflows that run coding agents: untrusted triggers with secrets, issue/PR text in prompts or shell scripts, `pull_request_target` with fork code, unrestricted agent tools, permissions, unpinned agent actions. Runs locally. |
+| `codexguild_lint_instructions` | Lints the project's agent instruction files (`CLAUDE.md`, `AGENTS.md`, `GEMINI.md`, `.cursorrules`…): size per session, missing build/test commands, README copy, generic advice, secrets, machine-specific paths, prompt injection. Runs locally — file contents are not uploaded. |
 
 If your harness can't start local processes, use the remote endpoint `https://api.codexguild.com/v1/mcp` directly
 (see [MCP docs](https://codexguild.com/docs/mcp)).
 
 ## Setup
 
-1. Create an agent key in the [CodexGuild dashboard](https://codexguild.com/dashboard#agents) (`cgk_…`).
+1. Create an agent key in the [CodexGuild dashboard](https://codexguild.com/dashboard/agents) (`cgk_…`).
 2. Add the server to your harness:
 
 ```json
@@ -39,11 +41,27 @@ claude mcp add codexguild --scope user -e CODEXGUILD_API_KEY=cgk_... -- npx -y @
 
 Per-harness snippets (Codex, Hermes, OpenCode, Cursor, Gemini CLI, …): <https://codexguild.com/connect>.
 
+## Guard hook (Claude Code PreToolUse)
+
+`codexguild-mcp guard` reads every Bash command before it runs:
+
+- **Destructive commands** — checked locally, no key or network: denies `rm -rf` of `/`, your home or system
+  directories, deletes through an unset variable (`rm -rf $DIR/`), disk writes and secrets sent over the network; asks
+  before deletes outside the project, force pushes, `git reset --hard`, database resets, `terraform destroy`, volume and
+  cloud-resource deletes. Rules: https://codexguild.com/docs/command-guard
+- **Packages** — before an install command (npm/pnpm/yarn/bun add, npx/bunx/pnpm dlx, pip/uv/poetry/pipx, cargo add,
+  go get/install) it checks the packages with CodexGuild: `block` (doesn't exist or reported malicious) → deny; `warn` →
+  ask. Only package names and versions are sent; errors let the command run.
+
+```json
+{ "hooks": { "PreToolUse": [ { "matcher": "Bash", "hooks": [{ "type": "command", "command": "npx -y @codexguild/mcp@latest guard", "timeout": 20 }] } ] } }
+```
+
 ## Configuration
 
 | Variable | Default | |
 |---|---|---|
-| `CODEXGUILD_API_KEY` | — | Agent key. Without it only the offline `codexguild_scan_skills` works. |
+| `CODEXGUILD_API_KEY` | — | Agent key. Without it only the offline `codexguild_scan_skills`, `codexguild_lint_instructions`, `codexguild_scan_workflows` and the guard's command checks work. |
 | `CODEXGUILD_API_URL` | `https://api.codexguild.com/v1` | Override for self-hosted or local development. |
 
 Requires Node.js 20 or newer.

package/dist/codexguild-mcp.js

@@ -6,8 +6,8 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
-import { access } from "node:fs/promises";
-import { join as join3 } from "node:path";
+import { access, readdir as readdir3, readFile as readFile3 } from "node:fs/promises";
+import { isAbsolute as isAbsolute2, join as join4 } from "node:path";
 
 // src/local-scan.ts
 import { readdir, readFile, stat } from "node:fs/promises";
@@ -51,7 +51,10 @@ var LINE_RULES = [
     title: "Reverse shell pattern",
     why: "Opens an interactive shell to a remote host \u2014 full remote control of the machine.",
     scope: "all",
-    pattern: /\/dev\/(tcp|udp)\/|\bnc(at)?\b[^\n]*\s(-e|-c|--exec|--sh-exec)\s|\bsocat\b[^\n]*\bexec:|\bbash\s+-i\s*>&|pty\.spawn\(\s*["']\/bin\/(ba)?sh/i
+    pattern: (
+      // /dev/tcp only when a shell's stdin/stdout is wired to it — `cat < /dev/null > /dev/tcp/host/port` is a port probe.
+      /(>&|<>|0<&)\s*\/dev\/(tcp|udp)\/|\/dev\/(tcp|udp)\/[^\n]*(0>&1|[<>]&\s*\d|\|\s*\/?(bin\/)?(ba|z)?sh\b)|\bnc(at)?\b[^\n]*\s(-e|-c|--exec|--sh-exec)\s|\bsocat\b[^\n]*\bexec:|\bbash\s+-i\s*>&|pty\.spawn\(\s*["']\/bin\/(ba)?sh/i
+    )
   },
   {
     id: "encoded-exec",
@@ -95,7 +98,9 @@ var LINE_RULES = [
     title: "Instructions that override the agent or hide actions from the user",
     why: "Skills are loaded into the agent context verbatim; these phrases try to subvert the agent's instructions or keep the user uninformed.",
     scope: "markdown",
-    pattern: /\b(ignore|disregard|forget|override)\s+(all\s+|any\s+|the\s+)?(previous|prior|above|earlier|system|original)\s+(instructions|prompts?|rules|guidelines|directives)|\b(do\s+not|don't|never)\s+(tell|inform|notify|alert|mention\s+(this\s+)?to)\s+the\s+user(?!\s+to\b)|\bhide\s+(this|these|it|the\s+\w+)\s+(from\s+the\s+user|actions?)|\byou\s+are\s+now\s+(in\s+)?(developer|dan|jailbreak|unrestricted|god)\s*mode|(?<!\b(would|could|might|may|can|will|to)\s)\bsilently\s+(run|execute|install|delete|send|upload)/i
+    pattern: /\b(ignore|disregard|forget|override)\s+(all\s+|any\s+|the\s+)?(previous|prior|above|earlier|system|original)\s+(instructions|prompts?|rules|guidelines|directives)|\b(do\s+not|don't|never)\s+(tell|inform|notify|alert|mention\s+(this\s+)?to)\s+the\s+user(?!\s+to\b)|\bhide\s+(this|these|it|the\s+\w+)\s+(from\s+the\s+user(?!'s)|actions?)|\byou\s+are\s+now\s+(in\s+)?(developer|dan|jailbreak|unrestricted|god)\s*mode|(?<!\b(would|could|might|may|can|will|to)\s)\bsilently\s+(run|execute|install|delete|send|upload)\b/i,
+    // "Do not tell the user their tickets are for sale unless it says live" keeps the user from being misinformed.
+    unless: /\b(do\s+not|don't|never)\s+(tell|inform)\s+the\s+user\b[^.!?]*\b(is|are)\b[^.!?]*\b(unless|until)\b/i
   },
   {
     id: "prompt-injection",
@@ -261,8 +266,225 @@ var LINE_RULES = [
 ];
 var HIDDEN_UNICODE = /[​-‍⁠-⁤⁦-⁩‪-‮]|[\u{E0000}-\u{E007F}\u{E0100}-\u{E01EF}]/gu;
 
+// ../scanner/src/instructions.ts
+var WEIGHT = { high: 25, medium: 10, low: 3 };
+var README_HEADINGS = /^#{1,3}\s*(installation|install|license|licen[cs]e|contributing|contributors|badges?|table of contents|toc|features|screenshots?|demo|acknowledg(e)?ments?|sponsors?|changelog|roadmap|faq|support|authors?)\s*$/i;
+var COMMAND = /\b(npm|pnpm|yarn|bun|npx|bunx|pip|uv|poetry|pytest|python3?|go|cargo|make|just|gradle|\.\/gradlew|mvn|dotnet|bundle|rake|rails|php|composer|mix|deno|docker( compose)?|kubectl|terraform|tox|nox|ruff|eslint|prettier|tsc|jest|vitest|playwright)\s+[\w:./-]+/;
+var COMMAND_START = new RegExp(`^(?:sudo\\s+|\\w+=\\S+\\s+)*${COMMAND.source}`);
+var VAGUE = /\b(write (clean|good|readable|maintainable) code|follow best practices|use (good|meaningful|descriptive) (names|naming)|be careful|make sure (the )?code (is|works)|keep (it|things|the code) simple|use common sense|write (good|proper) tests)\b/i;
+var SECRET = /\b(sk-(?:ant-|proj-)?[A-Za-z0-9_-]{20,}|AKIA[0-9A-Z]{16}|gh[pousr]_[A-Za-z0-9]{30,}|xox[abpr]-[A-Za-z0-9-]{10,}|AIza[0-9A-Za-z_-]{30,}|-----BEGIN [A-Z ]*PRIVATE KEY-----|cgk_[A-Za-z0-9]{20,})/;
+var ABS_PATH = /(?:^|[\s`'"(])(\/Users\/[^/\s`'"]+|\/home\/[^/\s`'"]+|[A-Z]:\\Users\\[^\\\s`'"]+)/;
+var SHOUT = /\b(IMPORTANT|CRITICAL|MUST|NEVER|ALWAYS|DO NOT)\b/g;
+function grade(score) {
+  return score >= 90 ? "A" : score >= 75 ? "B" : score >= 60 ? "C" : score >= 40 ? "D" : "F";
+}
+function lintInstructions(content, filename = "AGENTS.md") {
+  const issues = [];
+  const lines = content.split(/\r?\n/);
+  const approxTokens = Math.ceil(content.length / 4);
+  let inFence = false;
+  let codeBlocks = 0;
+  let commands2 = 0;
+  let headings = 0;
+  const seen = /* @__PURE__ */ new Map();
+  lines.forEach((raw, i) => {
+    const line = raw.trimEnd();
+    const n = i + 1;
+    if (/^\s*(```|~~~)/.test(line)) {
+      if (!inFence) codeBlocks++;
+      inFence = !inFence;
+      return;
+    }
+    const code = inFence ? line : /^\s*\$\s/.test(line) ? line.replace(/^\s*\$\s/, "") : [...line.matchAll(/`([^`]+)`/g)].map((m) => m[1]).join("\n");
+    if (code && code.split("\n").some((c) => COMMAND_START.test(c.trim()))) commands2++;
+    if (inFence) return;
+    if (/^#{1,6}\s/.test(line)) {
+      headings++;
+      if (README_HEADINGS.test(line.trim())) {
+        issues.push({ id: "readme-section", severity: "medium", line: n, title: `README section "${line.replace(/^#+\s*/, "")}"`, detail: "Install/license/contributing sections are for humans and already in the README. In an instruction file they cost tokens every session without changing what the agent does." });
+      }
+    }
+    if (/!\[[^\]]*\]\(https?:\/\/(img\.)?shields\.io|badge(n)?\.svg|\[!\[/.test(line)) {
+      issues.push({ id: "badges", severity: "low", line: n, title: "Badges", detail: "Badges carry no instructions; drop them from the agent file." });
+    }
+    if (VAGUE.test(line)) {
+      issues.push({ id: "vague-rule", severity: "low", line: n, title: "Generic advice", detail: `"${line.trim().slice(0, 80)}" \u2014 agents already try to do this. Replace it with the project-specific rule you actually mean (naming scheme, error handling pattern, which test command).` });
+    }
+    if (SECRET.test(line)) {
+      issues.push({ id: "secret", severity: "high", line: n, title: "Looks like a secret", detail: "Instruction files are committed and sent to the model provider every session. Move the value to an env var or secret store and rotate it." });
+    }
+    if (ABS_PATH.test(line)) {
+      issues.push({ id: "absolute-path", severity: "low", line: n, title: "Machine-specific path", detail: "A home-directory path only works on one machine; use paths relative to the repo root." });
+    }
+    const key = line.trim().toLowerCase();
+    if (key.length > 30) {
+      if (seen.has(key)) issues.push({ id: "duplicate", severity: "low", line: n, title: "Repeated line", detail: `Same as line ${seen.get(key)}.` });
+      else seen.set(key, n);
+    }
+  });
+  if (approxTokens > 8e3) {
+    issues.push({ id: "too-long", severity: "high", title: `~${approxTokens.toLocaleString("en-US")} tokens`, detail: `${filename} is loaded into every session. Past a few thousand tokens it crowds out the task and rules get ignored \u2014 keep the essentials here and move reference material into docs the agent reads on demand (or skills).` });
+  } else if (approxTokens > 2500) {
+    issues.push({ id: "long", severity: "medium", title: `~${approxTokens.toLocaleString("en-US")} tokens`, detail: `${filename} is loaded into every session; aim for under ~2,500 tokens of rules and commands.` });
+  }
+  if (content.trim() && !commands2) {
+    issues.push({ id: "no-commands", severity: "medium", title: "No build/test commands", detail: "The most useful thing an instruction file gives an agent is the exact commands to build, test and lint. Without them it guesses (and often runs the wrong ones)." });
+  }
+  if (lines.length > 40 && headings < 2) {
+    issues.push({ id: "no-structure", severity: "low", title: "No sections", detail: "Split the file into a few headed sections (Commands, Architecture, Conventions, Don'ts) so rules are easy to find and update." });
+  }
+  const shouts = content.match(SHOUT)?.length ?? 0;
+  if (shouts > 15) {
+    issues.push({ id: "shouting", severity: "low", title: `${shouts} all-caps emphasis words`, detail: "When everything is IMPORTANT nothing is. Keep caps for the two or three rules that really are hard limits." });
+  }
+  const scan = scanSkill([{ path: filename.endsWith(".md") ? filename : `${filename}.md`, content }]);
+  for (const f of scan.findings) {
+    issues.push({ id: `security:${f.ruleId}`, severity: f.severity === "critical" || f.severity === "high" ? "high" : f.severity === "medium" ? "medium" : "low", line: f.line, title: f.title, detail: `${f.why} \u2014 ${f.snippet}` });
+  }
+  const order = { high: 0, medium: 1, low: 2 };
+  issues.sort((a, b) => order[a.severity] - order[b.severity] || (a.line ?? 0) - (b.line ?? 0));
+  const counted = /* @__PURE__ */ new Set();
+  let penalty = 0;
+  for (const i of issues) {
+    const k = i.severity === "low" ? i.id : `${i.id}:${i.line ?? ""}`;
+    if (counted.has(k)) continue;
+    counted.add(k);
+    penalty += WEIGHT[i.severity];
+  }
+  const score = content.trim() ? Math.max(0, 100 - penalty) : 0;
+  return { score, grade: grade(score), stats: { lines: lines.length, approxTokens, headings, codeBlocks, commands: commands2 }, issues: issues.slice(0, 100) };
+}
+
+// ../scanner/src/workflows.ts
+var WEIGHT2 = { critical: 45, high: 25, medium: 10, low: 3 };
+var AGENT_ACTIONS = [
+  [/anthropics\/claude-code(-base)?-action/i, "Claude Code"],
+  [/google-github-actions\/run-gemini-cli|google-gemini\/gemini-cli-action/i, "Gemini CLI"],
+  [/openai\/codex-action/i, "Codex"],
+  [/sst\/opencode\/github|opencode-ai\/opencode-action/i, "OpenCode"],
+  [/cline\/cline-action|cline-bot/i, "Cline"],
+  [/aider-ai\/aider-action|paul-gauthier\/aider/i, "Aider"],
+  [/github\/copilot-(swe-)?agent/i, "Copilot agent"]
+];
+var AGENT_CLIS = [
+  [/\bclaude\s+(-p|--print)\b|@anthropic-ai\/claude-code\b/, "Claude Code"],
+  [/\bcodex\s+(exec|e)\b|@openai\/codex\b/, "Codex"],
+  [/\bgemini\s+(-p|--prompt)\b|@google\/gemini-cli\b/, "Gemini CLI"],
+  [/\bopencode\s+run\b/, "OpenCode"],
+  [/\baider\s+.*--(message|msg)\b/, "Aider"]
+];
+var UNTRUSTED_EVENTS = ["pull_request_target", "issue_comment", "issues", "pull_request_review", "pull_request_review_comment", "discussion", "discussion_comment", "workflow_run"];
+var UNTRUSTED_EXPR = /\$\{\{\s*(github\.event\.(issue|pull_request|comment|review|review_comment|discussion|head_commit|commits\[\d+\]|workflow_run)\.(?:[\w.]*\.)?(title|body|message|name|label|ref|head_branch|display_title)|github\.head_ref|github\.event\.pull_request\.head\.(ref|label))\s*\}\}/;
+var AUTHOR_GATE = /author_association|github\.actor\s*==|github\.triggering_actor|github\.event\.sender\.login\s*==|contains\(fromJSON\(['"]\[["'](OWNER|MEMBER|COLLABORATOR)/i;
+var DANGEROUS_FLAGS = [
+  [/--dangerously-skip-permissions/, "Claude Code runs every tool without asking (--dangerously-skip-permissions)"],
+  [/--dangerously-bypass-approvals-and-sandbox|--yolo\b/, "the agent runs without approvals or sandbox (--yolo / --dangerously-bypass-approvals-and-sandbox)"],
+  [/\b(allowed_tools|allowedTools|--allowedTools|--allowed-tools)\b[^\n]*["',\s[]Bash(?!\()/, "the agent may run any shell command (Bash allowed without a command pattern)"]
+];
+function grade2(score) {
+  return score >= 90 ? "A" : score >= 75 ? "B" : score >= 60 ? "C" : score >= 40 ? "D" : "F";
+}
+function blocks(lines) {
+  const out = [];
+  let kind = null;
+  let indent = -1;
+  for (const raw of lines) {
+    const ind = raw.length - raw.trimStart().length;
+    if (kind && raw.trim() && ind <= indent) kind = null;
+    const m = raw.match(/^(\s*)(?:-\s+)?(run|prompt|direct_prompt|override_prompt|custom_instructions|claude_args|codex_args|gemini_args|args|message):\s*(.*)$/);
+    if (m) {
+      const k = m[2] === "run" ? "run" : "prompt";
+      out.push(k);
+      kind = /^[|>][-+]?\s*$/.test(m[3]) || m[3] === "" ? k : null;
+      indent = m[1].length + (raw.trimStart().startsWith("-") ? 2 : 0);
+      continue;
+    }
+    out.push(kind);
+  }
+  return out;
+}
+function lintWorkflow(content) {
+  const issues = [];
+  const lines = content.split(/\r?\n/);
+  const text2 = lines.map((l) => l.replace(/\s+#.*$/, "")).join("\n");
+  const agents = /* @__PURE__ */ new Set();
+  const agentLines = [];
+  lines.forEach((l, i) => {
+    for (const [re, name] of [...AGENT_ACTIONS, ...AGENT_CLIS]) if (re.test(l)) {
+      agents.add(name);
+      agentLines.push(i + 1);
+    }
+  });
+  const untrustedTriggers = UNTRUSTED_EVENTS.filter((e) => new RegExp(`(^|[\\s,[{'"-])${e}\\s*(:|,|\\]|$)`, "m").test(text2));
+  const hasAgent = agents.size > 0;
+  const secrets = [...text2.matchAll(/\$\{\{\s*secrets\.(\w+)\s*\}\}/g)].map((m) => m[1]).filter((s) => s !== "GITHUB_TOKEN");
+  const gated = AUTHOR_GATE.test(text2);
+  const kinds = blocks(lines);
+  const firstAgent = agentLines[0];
+  if (hasAgent && untrustedTriggers.length && secrets.length && !gated) {
+    issues.push({
+      id: "untrusted-trigger-with-secrets",
+      severity: "critical",
+      line: firstAgent,
+      title: `Anyone can start ${[...agents].join(" / ")} with your secrets (${untrustedTriggers.join(", ")})`,
+      detail: `${untrustedTriggers.join(", ")} runs for outside contributors, and this job gives the agent ${[...new Set(secrets)].slice(0, 4).join(", ")}. A crafted title, body or comment can steer the agent into revealing or misusing them. Restrict who can trigger it (check github.event.comment.author_association / sender against OWNER, MEMBER, COLLABORATOR), or move secrets to a workflow that only maintainers trigger.`
+    });
+  } else if (hasAgent && untrustedTriggers.length && !gated) {
+    issues.push({
+      id: "untrusted-trigger",
+      severity: "medium",
+      line: firstAgent,
+      title: `Outside contributors can start the agent (${untrustedTriggers.join(", ")})`,
+      detail: "No author check was found. Even without secrets, the agent spends your quota and can write to the repository with the job token. Gate it on author_association."
+    });
+  }
+  if (untrustedTriggers.includes("pull_request_target")) {
+    lines.forEach((l, i) => {
+      if (/^\s*ref:\s*\$\{\{\s*(github\.event\.pull_request\.head\.(sha|ref)|github\.head_ref)\s*\}\}/.test(l)) {
+        issues.push({ id: "prt-checkout-head", severity: "critical", line: i + 1, title: "pull_request_target checks out the pull request code", detail: "The job runs with your secrets and a write token, and now with code from the fork. Anything the agent or a build step executes from that checkout can steal them. Use pull_request for untrusted code, or check out the base branch only." });
+      }
+    });
+  }
+  lines.forEach((l, i) => {
+    const m = l.match(UNTRUSTED_EXPR);
+    if (!m) return;
+    const kind = kinds[i];
+    if (kind === "run") {
+      issues.push({ id: "untrusted-in-run", severity: "high", line: i + 1, title: `Untrusted ${m[1].split(".").slice(-2).join(".")} expanded inside a shell`, detail: 'The value is pasted into the script before it runs, so a title like `"; curl \u2026 | sh #` executes. Pass it through env: (VALUE: ${{ \u2026 }}) and use "$VALUE" in the script.' });
+    } else if (kind === "prompt" || hasAgent) {
+      issues.push({ id: "untrusted-in-prompt", severity: hasAgent ? "high" : "medium", line: i + 1, title: `Untrusted ${m[1].split(".").slice(-2).join(".")} inserted into the agent's prompt`, detail: "Text from outside contributors becomes instructions to the agent \u2014 the prompt-injection path behind the 2026 agent-action key leaks. Let the agent read the issue/PR through its tools as data, keep tools and permissions minimal, and never give this job secrets it does not need." });
+    }
+  });
+  lines.forEach((l, i) => {
+    for (const [re, what] of DANGEROUS_FLAGS) {
+      if (re.test(l)) {
+        const severe = untrustedTriggers.length > 0 && !gated;
+        issues.push({ id: "agent-unrestricted", severity: severe ? "high" : "medium", line: i + 1, title: `In CI, ${what}`, detail: severe ? "Combined with a trigger outside contributors control, a prompt injection can run arbitrary commands with the job token and secrets. Allow only the commands the task needs (e.g. Bash(npm test))." : "Allow only the commands the task needs (e.g. Bash(npm test)); a prompt injection anywhere in the input then cannot run arbitrary commands." });
+      }
+    }
+  });
+  if (/^\s*permissions:\s*write-all\b/m.test(text2)) {
+    const n = lines.findIndex((l) => /permissions:\s*write-all/.test(l)) + 1;
+    issues.push({ id: "write-all", severity: hasAgent ? "high" : "medium", line: n, title: "permissions: write-all", detail: "The job token can push code, change releases and edit workflows. Grant only what the job needs (e.g. contents: read, pull-requests: write)." });
+  } else if (hasAgent && !/^\s*permissions:/m.test(text2)) {
+    issues.push({ id: "no-permissions", severity: "medium", title: "No permissions block", detail: "Without one, the job token gets the repository default, which is often read/write for everything. Declare the minimum (contents: read, plus what the agent must write)." });
+  }
+  lines.forEach((l, i) => {
+    const m = l.match(/uses:\s*([\w.-]+\/[\w./-]+)@([\w.-]+)/);
+    if (!m || !AGENT_ACTIONS.some(([re]) => re.test(m[1]))) return;
+    if (!/^[0-9a-f]{40}$/.test(m[2])) {
+      issues.push({ id: "unpinned-agent-action", severity: "medium", line: i + 1, title: `${m[1]}@${m[2]} is not pinned to a commit`, detail: "This action receives your API keys. A moved tag or a compromised release changes what runs with them. Pin the full commit SHA (with the version in a comment) and update deliberately." });
+    }
+  });
+  if (hasAgent && /secrets:\s*inherit/.test(text2)) {
+    issues.push({ id: "secrets-inherit", severity: "medium", line: lines.findIndex((l) => /secrets:\s*inherit/.test(l)) + 1, title: "secrets: inherit", detail: "Every repository secret is passed on. Pass only the key the agent needs." });
+  }
+  const score = Math.max(0, 100 - issues.reduce((n, x) => n + WEIGHT2[x.severity], 0));
+  return { score: hasAgent || issues.length ? score : 100, grade: grade2(score), agents: [...agents], untrustedTriggers, issues: issues.sort((a, b) => WEIGHT2[b.severity] - WEIGHT2[a.severity] || (a.line ?? 0) - (b.line ?? 0)) };
+}
+
 // ../scanner/src/index.ts
-var SCANNER_VERSION = "1.1.0";
+var SCANNER_VERSION = "1.2.0";
 var MAX_PER_RULE_PER_FILE = 5;
 var SEVERITY_ORDER = ["critical", "high", "medium", "low"];
 var MARKDOWN_EXT = /\.(md|mdx|markdown|txt|rst)$/i;
@@ -382,9 +604,10 @@ function scanSkill(files) {
           snippet: snippetOf(line)
         });
       }
+      const prose = scope === "markdown" && !inFence ? line.replace(/^\s*(?:>\s?)+/, "").replace(/<[a-z][\w -]{0,30}>/gi, "") : line;
       for (const rule of LINE_RULES) {
         if (rule.scope !== "all" && rule.scope !== scope) continue;
-        if (!matches(rule, line)) continue;
+        if (!matches(rule, rule.alsoRequires === WRITE_OP ? prose : line)) continue;
         if (scope === "markdown" && rule.alsoRequires && !inFence && line.includes("`")) {
           const spans = line.match(/`[^`]+`/g) ?? [];
           if (!spans.some((sp) => matches(rule, sp))) continue;
@@ -537,8 +760,9 @@ function formatLocalScan({ roots, reports }, verbose = false) {
 }
 
 // src/stack-detect.ts
-import { readdir as readdir2, readFile as readFile2 } from "node:fs/promises";
-import { basename, dirname, join as join2 } from "node:path";
+import { createHash as createHash2 } from "node:crypto";
+import { readdir as readdir2, readFile as readFile2, stat as stat2 } from "node:fs/promises";
+import { basename, dirname, join as join2, relative as relative2, resolve as resolve2, sep } from "node:path";
 async function read(path) {
   try {
     return await readFile2(path, "utf8");
@@ -546,31 +770,200 @@ async function read(path) {
     return null;
   }
 }
+async function isDir(path) {
+  try {
+    return (await stat2(path)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function isExactVersion(v) {
+  return !!v && /^v?\d+\.\d+\.\d+(?:[-+.][0-9A-Za-z.-]+)?$/.test(v.trim());
+}
+var pep503 = (name) => name.toLowerCase().replace(/[-_.]+/g, "-");
+var unquote = (s) => s.trim().replace(/^['"]|['"]$/g, "");
 function fromPackageJson(raw) {
   try {
     const pkg = JSON.parse(raw);
-    return [pkg.dependencies, pkg.devDependencies, pkg.peerDependencies].flatMap((deps) => Object.entries(deps ?? {})).map(([name, version]) => ({ name, version: String(version).replace(/^[~^>=<\s]+/, "").slice(0, 64) }));
+    return [pkg.dependencies, pkg.devDependencies, pkg.optionalDependencies].flatMap((deps) => Object.entries(deps ?? {})).map(([name, spec]) => ({ name, spec: String(spec).trim() })).filter((d) => !/^(workspace:|file:|link:|portal:)/.test(d.spec));
   } catch {
     return [];
   }
 }
+function nodeEngine(raw) {
+  try {
+    const e = JSON.parse(raw).engines?.node;
+    return e ? String(e).trim().slice(0, 64) : null;
+  } catch {
+    return null;
+  }
+}
+function npmLockResolver(raw, rel) {
+  let lock;
+  try {
+    lock = JSON.parse(raw);
+  } catch {
+    return () => null;
+  }
+  const prefix = rel && rel !== "." ? `${rel.split(sep).join("/")}/` : "";
+  return (name) => {
+    const p = lock.packages;
+    if (p) {
+      const hit = prefix && p[`${prefix}node_modules/${name}`] || p[`node_modules/${name}`];
+      if (hit && !hit.link && hit.version && !/^(file|link):/.test(hit.version)) return hit.version;
+      return null;
+    }
+    return lock.dependencies?.[name]?.version ?? null;
+  };
+}
+function pnpmLockResolver(raw, rel) {
+  const importer = !rel || rel === "." ? "." : rel.split(sep).join("/");
+  const out = /* @__PURE__ */ new Map();
+  const clean = (v) => unquote(v).replace(/\(.*$/, "").replace(/_.*$/, "");
+  let inImporters = false;
+  let current = null;
+  let pkg = null;
+  let inDeps = false;
+  for (const line of raw.split("\n")) {
+    if (/^importers:\s*$/.test(line)) {
+      inImporters = true;
+      continue;
+    }
+    if (!inImporters) continue;
+    if (/^\S/.test(line)) break;
+    let m = line.match(/^ {2}(\S.*?):\s*$/);
+    if (m) {
+      current = unquote(m[1]);
+      inDeps = false;
+      continue;
+    }
+    if (current !== importer) continue;
+    m = line.match(/^ {4}(\S+):\s*$/);
+    if (m) {
+      inDeps = /^(dependencies|devDependencies|optionalDependencies)$/.test(m[1]);
+      continue;
+    }
+    if (!inDeps) continue;
+    m = line.match(/^ {6}(\S.*?):\s*(.*)$/);
+    if (m) {
+      pkg = unquote(m[1]);
+      if (m[2] && !/^\s*$/.test(m[2])) out.set(pkg, clean(m[2]));
+      continue;
+    }
+    m = line.match(/^ {8}version:\s*(.+)$/);
+    if (m && pkg) out.set(pkg, clean(m[1]));
+  }
+  return (name) => {
+    const v = out.get(name);
+    return v && !/^(link|file|workspace):/.test(v) ? v : null;
+  };
+}
+function yarnLockResolver(raw) {
+  const bySpec = /* @__PURE__ */ new Map();
+  const byName = /* @__PURE__ */ new Map();
+  let keys = [];
+  for (const line of raw.split("\n")) {
+    if (/^\S.*:\s*$/.test(line) && !line.startsWith("#") && !line.startsWith("__metadata")) {
+      keys = line.replace(/:\s*$/, "").split(/,\s*/).map(unquote).filter(Boolean);
+      continue;
+    }
+    const m = line.match(/^ {2}version:?\s+"?([^"\s]+)"?\s*$/);
+    if (m && keys.length) {
+      for (const k of keys) {
+        const at = k.lastIndexOf("@");
+        if (at <= 0) continue;
+        const name = k.slice(0, at);
+        const spec = k.slice(at + 1).replace(/^npm:/, "");
+        bySpec.set(`${name}@${spec}`, m[1]);
+        if (!byName.has(name)) byName.set(name, m[1]);
+      }
+      keys = [];
+    }
+  }
+  return (name, spec) => bySpec.get(`${name}@${spec}`) ?? byName.get(name) ?? null;
+}
+function bunLockResolver(raw) {
+  let pkgs = {};
+  try {
+    pkgs = JSON.parse(raw.replace(/,(\s*[}\]])/g, "$1")).packages ?? {};
+  } catch {
+    return () => null;
+  }
+  return (name) => {
+    const id = pkgs[name]?.[0];
+    if (typeof id !== "string") return null;
+    const v = id.slice(id.lastIndexOf("@") + 1);
+    return /^\d/.test(v) ? v : null;
+  };
+}
 function fromRequirements(raw) {
-  return raw.split("\n").map((l) => l.replace(/#.*/, "").trim()).filter((l) => l && !l.startsWith("-")).map((l) => {
-    const m = l.match(/^([A-Za-z0-9_.-]+)(?:\[.*\])?\s*(?:[=~<>!]=?\s*([\w.*-]+))?/);
-    return m ? { name: m[1], ...m[2] ? { version: m[2] } : {} } : null;
+  return raw.split("\n").map((l) => l.replace(/#.*/, "").trim()).filter((l) => l && !l.startsWith("-") && !/^(git\+|https?:)/.test(l)).map((l) => {
+    const m = l.match(/^([A-Za-z0-9_.-]+)(?:\[.*?\])?\s*(===?|~=|>=|<=|!=|>|<)?\s*([\w.*+-]+)?/);
+    if (!m) return null;
+    const [, name, op, v] = m;
+    if (!v) return { name };
+    return { name, version: op === "==" || op === "===" ? v : `${op ?? ""}${v}`.slice(0, 64) };
   }).filter((d) => d !== null);
 }
 function fromPyproject(raw) {
-  const block = raw.match(/^\s*dependencies\s*=\s*\[([\s\S]*?)\]/m)?.[1] ?? "";
-  return fromRequirements([...block.matchAll(/["']([^"']+)["']/g)].map((m) => m[1]).join("\n"));
+  const pep621 = raw.match(/^\s*dependencies\s*=\s*\[([\s\S]*?)\]/m)?.[1] ?? "";
+  const deps = fromRequirements([...pep621.matchAll(/["']([^"']+)["']/g)].map((m) => m[1]).join("\n"));
+  const poetry = raw.match(/^\[tool\.poetry\.(?:dev-)?dependencies\]\s*$([\s\S]*?)(?=^\[|(?![\s\S]))/m)?.[1] ?? "";
+  for (const m of poetry.matchAll(/^([A-Za-z0-9_.-]+)\s*=\s*(?:"([^"]*)"|\{[^}]*version\s*=\s*"([^"]*)")/gm)) {
+    if (m[1].toLowerCase() === "python") continue;
+    deps.push({ name: m[1], ...m[2] ?? m[3] ? { version: (m[2] ?? m[3]).slice(0, 64) } : {} });
+  }
+  return deps;
+}
+function tomlPackages(raw, normalize2 = pep503) {
+  const out = /* @__PURE__ */ new Map();
+  for (const block of raw.split(/^\[\[package\]\]\s*$/m).slice(1)) {
+    const name = block.match(/^name\s*=\s*"([^"]+)"/m)?.[1];
+    const version = block.match(/^version\s*=\s*"([^"]+)"/m)?.[1];
+    if (name && version && !out.has(normalize2(name))) out.set(normalize2(name), version);
+  }
+  return out;
+}
+function pipfileLock(raw) {
+  const out = /* @__PURE__ */ new Map();
+  try {
+    const j = JSON.parse(raw);
+    for (const section of [j.default, j.develop]) {
+      for (const [name, v] of Object.entries(section ?? {})) {
+        const ver = v.version?.replace(/^==/, "");
+        if (ver) out.set(pep503(name), ver);
+      }
+    }
+  } catch {
+  }
+  return out;
 }
 function fromGoMod(raw) {
-  return [...raw.matchAll(/^\s*(?:require\s+)?([\w.-]+\.[\w.-]+\/[\w./-]+)\s+(v[\w.+-]+)/gm)].map((m) => ({
-    name: m[1],
-    version: m[2]
-  }));
+  return [...raw.matchAll(/^\s*(?:require\s+)?([\w.-]+\.[\w.-]+\/[\w./-]+)\s+(v[\w.+-]+)/gm)].map((m) => ({ name: m[1], version: m[2] }));
+}
+function fromCargoToml(raw) {
+  const deps = [];
+  const sections = raw.matchAll(/^\[(?:workspace\.)?(?:dev-|build-)?dependencies\]\s*$([\s\S]*?)(?=^\[|(?![\s\S]))/gm);
+  for (const s of sections) {
+    for (const m of s[1].matchAll(/^([A-Za-z0-9_-]+)\s*=\s*(?:"([^"]*)"|\{([^}]*)\})/gm)) {
+      const v = m[2] ?? m[3]?.match(/version\s*=\s*"([^"]*)"/)?.[1];
+      deps.push({ name: m[1], ...v ? { version: v.slice(0, 64) } : {} });
+    }
+  }
+  return deps;
 }
-var SKIP = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", ".next", "vendor", "venv", ".venv", "coverage", "tmp"]);
+async function runtimes(dir, pkgRaw) {
+  const out = [];
+  const node = (await read(join2(dir, ".nvmrc")))?.trim() || (await read(join2(dir, ".node-version")))?.trim();
+  const tool = await read(join2(dir, ".tool-versions"));
+  const toolNode = tool?.match(/^(?:nodejs|node)\s+(\S+)/m)?.[1];
+  const nodeVersion = node || toolNode || (pkgRaw ? nodeEngine(pkgRaw) : null);
+  if (nodeVersion && /\d/.test(nodeVersion)) out.push({ name: "node", version: nodeVersion.replace(/^v/, "").slice(0, 64), runtime: true });
+  const py = (await read(join2(dir, ".python-version")))?.trim().split("\n")[0] || tool?.match(/^python\s+(\S+)/m)?.[1];
+  if (py && /^\d/.test(py)) out.push({ name: "python", version: py.slice(0, 64), runtime: true });
+  return out;
+}
+var SKIP = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", ".next", "vendor", "venv", ".venv", "coverage", "tmp", "target", "__pycache__"]);
 async function subdirs(dir) {
   try {
     return (await readdir2(dir, { withFileTypes: true })).filter((e) => e.isDirectory() && !e.name.startsWith(".") && !SKIP.has(e.name)).map((e) => join2(dir, e.name));
@@ -578,27 +971,113 @@ async function subdirs(dir) {
     return [];
   }
 }
+async function projectRoot(cwd) {
+  let dir = resolve2(cwd);
+  for (; ; ) {
+    if (await isDir(join2(dir, ".git")) || await read(join2(dir, ".git")) !== null) return dir;
+    const up = dirname(dir);
+    if (up === dir) return resolve2(cwd);
+    dir = up;
+  }
+}
+async function projectKey(cwd) {
+  const root = await projectRoot(cwd);
+  return `${basename(root).slice(0, 100)}#${createHash2("sha256").update(root).digest("hex").slice(0, 8)}`;
+}
+async function findUp(dir, stop, names) {
+  let d = dir;
+  for (; ; ) {
+    for (const n of names) if (await read(join2(d, n)) !== null) return { path: join2(d, n), dir: d };
+    if (d === stop || dirname(d) === d) return null;
+    d = dirname(d);
+  }
+}
+var NPM_LOCKS = ["package-lock.json", "npm-shrinkwrap.json", "pnpm-lock.yaml", "yarn.lock", "bun.lock"];
+async function npmResolver(dir, root, used) {
+  const lock = await findUp(dir, root, NPM_LOCKS);
+  if (!lock) return () => null;
+  const raw = await read(lock.path) ?? "";
+  used.add(lock.path);
+  const rel = relative2(lock.dir, dir) || ".";
+  const file = basename(lock.path);
+  if (file === "pnpm-lock.yaml") return pnpmLockResolver(raw, rel);
+  if (file === "yarn.lock") return yarnLockResolver(raw);
+  if (file === "bun.lock") return bunLockResolver(raw);
+  return npmLockResolver(raw, rel);
+}
+async function pythonLock(dir, root, used) {
+  const lock = await findUp(dir, root, ["poetry.lock", "uv.lock", "Pipfile.lock"]);
+  if (!lock) return /* @__PURE__ */ new Map();
+  used.add(lock.path);
+  const raw = await read(lock.path) ?? "";
+  return basename(lock.path) === "Pipfile.lock" ? pipfileLock(raw) : tomlPackages(raw);
+}
 async function detectStack(cwd = process.cwd()) {
-  const level1 = await subdirs(cwd);
+  const base = resolve2(cwd);
+  const root = await projectRoot(base);
+  const level1 = await subdirs(base);
   const level2 = (await Promise.all(level1.map(subdirs))).flat();
-  const dirs = [cwd, ...level1, ...level2].slice(0, 400);
-  const parsers = [
-    ["package.json", fromPackageJson],
-    ["requirements.txt", fromRequirements],
-    ["pyproject.toml", fromPyproject],
-    ["go.mod", fromGoMod]
-  ];
+  const dirs = [base, ...level1, ...level2].slice(0, 400);
   const deps = /* @__PURE__ */ new Map();
   const manifests = [];
+  const locks = /* @__PURE__ */ new Set();
+  const add = (d) => {
+    const key = `${d.runtime ? "runtime" : d.ecosystem}:${d.ecosystem === "pypi" ? pep503(d.name) : d.name.toLowerCase()}@${d.version ?? ""}`;
+    if (!deps.has(key)) deps.set(key, d);
+  };
+  const rel = (p) => relative2(base, p) || basename(p);
   for (const dir of dirs) {
-    for (const [file, parse] of parsers) {
-      const raw = await read(join2(dir, file));
-      if (raw === null) continue;
-      manifests.push(join2(dir, file).slice(cwd.length + 1) || file);
-      for (const d of parse(raw)) if (!deps.has(d.name.toLowerCase())) deps.set(d.name.toLowerCase(), d);
+    const pkgRaw = await read(join2(dir, "package.json"));
+    if (pkgRaw !== null) {
+      manifests.push(rel(join2(dir, "package.json")));
+      const resolveVersion = await npmResolver(dir, root, locks);
+      for (const { name, spec } of fromPackageJson(pkgRaw)) {
+        const locked = resolveVersion(name, spec);
+        add({ name, ecosystem: "npm", ...locked ?? spec ? { version: (locked ?? spec).slice(0, 64) } : {} });
+      }
+    }
+    for (const r of await runtimes(dir, pkgRaw)) add(r);
+    const req = await read(join2(dir, "requirements.txt"));
+    const pyproject = await read(join2(dir, "pyproject.toml"));
+    if (req !== null || pyproject !== null) {
+      const locked = await pythonLock(dir, root, locks);
+      const pyDeps = [...req !== null ? fromRequirements(req) : [], ...pyproject !== null ? fromPyproject(pyproject) : []];
+      if (req !== null) manifests.push(rel(join2(dir, "requirements.txt")));
+      if (pyproject !== null) manifests.push(rel(join2(dir, "pyproject.toml")));
+      for (const d of pyDeps) {
+        const v = locked.get(pep503(d.name)) ?? d.version;
+        add({ name: d.name, ecosystem: "pypi", ...v ? { version: v } : {} });
+      }
+    }
+    const gomod = await read(join2(dir, "go.mod"));
+    if (gomod !== null) {
+      manifests.push(rel(join2(dir, "go.mod")));
+      for (const d of fromGoMod(gomod)) add({ ...d, ecosystem: "go" });
+    }
+    const cargo = await read(join2(dir, "Cargo.toml"));
+    if (cargo !== null) {
+      manifests.push(rel(join2(dir, "Cargo.toml")));
+      const lock = await findUp(dir, root, ["Cargo.lock"]);
+      const locked = lock ? tomlPackages(await read(lock.path) ?? "", (n) => n.toLowerCase()) : /* @__PURE__ */ new Map();
+      if (lock) locks.add(lock.path);
+      for (const d of fromCargoToml(cargo)) {
+        const v = locked.get(d.name.toLowerCase()) ?? d.version;
+        add({ name: d.name, ecosystem: "cargo", ...v ? { version: v } : {} });
+      }
     }
   }
-  return { deps: [...deps.values()].slice(0, 300), manifests };
+  const all = [...deps.values()];
+  const exactOf = (d) => d.ecosystem === "go" && !!d.version || isExactVersion(d.version);
+  all.sort((a, b) => Number(exactOf(b)) - Number(exactOf(a)));
+  const sent = all.slice(0, 300);
+  const exact = sent.filter((d) => !d.runtime && exactOf(d)).length;
+  return {
+    deps: sent,
+    manifests,
+    lockfiles: [...locks].map((p) => relative2(base, p) || basename(p)),
+    exact,
+    ranges: sent.filter((d) => !d.runtime).length - exact
+  };
 }
 async function installedSkillNames(skillDirs) {
   const names = /* @__PURE__ */ new Set();
@@ -610,13 +1089,298 @@ async function installedSkillNames(skillDirs) {
   return [...names];
 }
 
+// src/destructive.ts
+import { realpathSync } from "node:fs";
+import { homedir as homedir2, tmpdir } from "node:os";
+import { isAbsolute, join as join3, normalize, resolve as resolve3, sep as sep2 } from "node:path";
+function split(line) {
+  return line.split(/&&|\|\||[;\n]/).flatMap((part) => part.split(/(?<!\|)\|(?!\|)/).map((raw) => raw.trim())).filter(Boolean).map((raw) => ({ raw, words: (raw.match(/"[^"]*"|'[^']*'|\S+/g) ?? []).map((w) => w.replace(/^["']|["']$/g, "")) }));
+}
+function strip(words) {
+  let w = words;
+  while (w.length && /^(sudo|doas|env|time|nice|command|exec|\w+=\S*)$/.test(w[0])) w = w.slice(1);
+  return w;
+}
+var SYSTEM_DIRS = ["/", "/bin", "/boot", "/dev", "/etc", "/lib", "/lib64", "/opt", "/proc", "/root", "/sbin", "/sys", "/usr", "/var", "/System", "/Library", "/Applications", "/Users", "/home", "/private", "/Volumes"];
+function expand(arg, ctx) {
+  let out = arg.replace(/^~(?=$|\/)/, ctx.home);
+  let unresolved = false;
+  out = out.replace(/\$\{(\w+)(?::?[-=][^}]*)?\}|\$(\w+)/g, (m, a, b) => {
+    const name = a ?? b;
+    const v = name === "HOME" ? ctx.home : name === "PWD" ? ctx.cwd : ctx.env[name];
+    if (v === void 0 || v === "") {
+      if (/:?[-=]/.test(m)) return m.replace(/^\$\{\w+:?[-=]|\}$/g, "");
+      unresolved = true;
+      return "";
+    }
+    return v;
+  });
+  return unresolved ? null : out;
+}
+var within = (p, dir) => p === dir || p.startsWith(dir.endsWith(sep2) ? dir : dir + sep2);
+function real(p) {
+  try {
+    return realpathSync(p);
+  } catch {
+    return p;
+  }
+}
+function judgeDelete(target, ctx, flags) {
+  const expanded = expand(target, ctx);
+  if (expanded === null) {
+    return { decision: "deny", reason: `"${target}" contains a variable that is not set here, so it may expand to nothing \u2014 e.g. "rm -rf $DIR/" becomes "rm -rf /". Use the literal path.` };
+  }
+  if (/^\/?\*$|^~\/?\*$/.test(target) || expanded === "/*" || expanded === `${ctx.home}/*`) {
+    return { decision: "deny", reason: `"rm ${flags} ${target}" deletes everything in ${expanded.startsWith(ctx.home) ? "the home directory" : "the filesystem root"}.` };
+  }
+  const abs = normalize(isAbsolute(expanded) ? expanded : resolve3(ctx.cwd, expanded)).replace(/\/\*$/, "").replace(/(.)\/+$/, "$1") || "/";
+  const resolved = real(abs);
+  for (const p of /* @__PURE__ */ new Set([abs, resolved])) {
+    if (p === ctx.home || within(ctx.home, p)) return { decision: "deny", reason: `"rm ${flags} ${target}" would delete the home directory (${p}).` };
+    if (SYSTEM_DIRS.some((d) => p === d)) return { decision: "deny", reason: `"rm ${flags} ${target}" would delete the system directory ${p}.` };
+  }
+  const tmp = [real(tmpdir()), "/tmp", "/private/tmp", "/var/folders"];
+  const safe = (p) => within(p, ctx.project) || tmp.some((t) => within(p, t));
+  if (!safe(abs) || !safe(resolved)) {
+    const via = resolved !== abs ? ` (it resolves to ${resolved} through a link)` : "";
+    return { decision: "ask", reason: `"rm ${flags} ${target}" deletes ${abs}${via}, outside the project ${ctx.project}. Confirm that this is intended.` };
+  }
+  return null;
+}
+var RULES = [
+  // rm -r / -rf / --recursive
+  (w, _raw, ctx) => {
+    if (w[0]?.split("/").pop() !== "rm") return null;
+    const flags = w.filter((x) => x.startsWith("-"));
+    if (!flags.some((f) => /^-[a-zA-Z]*[rR]/.test(f) || f === "--recursive")) return null;
+    const targets = w.slice(1).filter((x) => !x.startsWith("-"));
+    let worst = null;
+    for (const t of targets) {
+      const v = judgeDelete(t, ctx, flags.join(" "));
+      if (v?.decision === "deny") return v;
+      worst ??= v;
+    }
+    return worst;
+  },
+  // find … -delete / -exec rm outside the project
+  (w, _raw, ctx) => {
+    if (w[0] !== "find" || !(w.includes("-delete") || w.includes("-exec") && w.includes("rm"))) return null;
+    const start = w[1] && !w[1].startsWith("-") ? w[1] : ".";
+    const v = judgeDelete(start, ctx, "(find -delete)");
+    return v && { ...v, reason: v.reason.replace(/^"rm \(find -delete\) /, `"find ${start} \u2026 -delete" `) };
+  },
+  // disks and filesystems
+  (w) => /^mkfs(\.\w+)?$/.test(w[0] ?? "") || w[0] === "dd" && w.some((x) => /^of=\/dev\//.test(x)) ? { decision: "deny", reason: `"${w.join(" ")}" overwrites a disk or partition.` } : null,
+  (_w, raw) => />\s*\/dev\/(sd|nvme|disk|hd)\w*/.test(raw) ? { decision: "deny", reason: "Writing directly to a disk device." } : null,
+  // recursive chmod/chown on / or ~
+  (w, _raw, ctx) => {
+    if (!["chmod", "chown"].includes(w[0] ?? "") || !w.some((x) => /^-[a-zA-Z]*R/.test(x))) return null;
+    const t = w.slice(1).filter((x) => !x.startsWith("-")).slice(1);
+    const hit = t.map((x) => expand(x, ctx) ?? "/").find((x) => SYSTEM_DIRS.includes(normalize(x)) || normalize(x) === ctx.home);
+    return hit ? { decision: "deny", reason: `Recursive ${w[0]} on ${hit}.` } : null;
+  },
+  // git
+  (w) => {
+    if (w[0] !== "git") return null;
+    const sub = w[1];
+    if (sub === "push" && w.some((x) => /^(-f|--force|--force-with-lease(=.*)?|--mirror|--delete|-d)$/.test(x) || /^\+/.test(x) || /^:/.test(x))) {
+      return { decision: "ask", reason: `"${w.join(" ")}" rewrites or deletes history on the remote. Confirm with the user first.` };
+    }
+    if (sub === "reset" && w.includes("--hard")) return { decision: "ask", reason: '"git reset --hard" throws away uncommitted changes.' };
+    if (sub === "clean" && w.some((x) => /^-[a-zA-Z]*f/.test(x))) return { decision: "ask", reason: `"${w.join(" ")}" permanently deletes untracked files${w.some((x) => /x/.test(x) && x.startsWith("-")) ? ", including ignored ones like .env" : ""}.` };
+    if ((sub === "checkout" || sub === "restore") && w.includes(".") && !w.includes("--staged")) return { decision: "ask", reason: `"${w.join(" ")}" discards all uncommitted changes.` };
+    if (sub === "branch" && w.includes("-D")) return { decision: "ask", reason: `"${w.join(" ")}" deletes a branch even if it is not merged.` };
+    if (sub === "add" && w.slice(2).some((x) => /(^|\/)\.env(\..+)?$|\.pem$|id_rsa|id_ed25519/.test(x) && !/\.example$|\.sample$|\.template$/.test(x))) {
+      return { decision: "ask", reason: `"${w.join(" ")}" stages a file that usually holds secrets.` };
+    }
+    return null;
+  },
+  // databases
+  (w, raw) => {
+    const s = raw.toLowerCase();
+    if (/\bprisma\b.*\bmigrate\s+reset\b/.test(s) || /\bprisma\b.*\bdb\s+push\b.*--(force-reset|accept-data-loss)/.test(s)) {
+      return { decision: "ask", reason: `"${raw.trim()}" deletes data in the database ${/database_url=/.test(s) ? "named in DATABASE_URL" : "from DATABASE_URL"}. Confirm it is not a shared or production database.` };
+    }
+    if (/\b(drizzle-kit\s+drop|rails\s+db:(drop|reset)|rake\s+db:(drop|reset)|manage\.py\s+flush|sequelize\s+db:drop|typeorm\s+schema:drop|knex\s+migrate:rollback\s+--all)\b/.test(s)) {
+      return { decision: "ask", reason: `"${raw.trim()}" drops or empties the database.` };
+    }
+    if (/\b(psql|mysql|mariadb|sqlite3|mongosh|mongo|redis-cli|clickhouse-client)\b/.test(s) && /\b(drop\s+(database|schema|table)|truncate\b|delete\s+from\s+\w+\s*(;|$|"|')|flushall|flushdb|dropdatabase\(\))/.test(s)) {
+      return { decision: "ask", reason: `"${raw.trim().slice(0, 200)}" deletes database data. Confirm the target is not production.` };
+    }
+    return null;
+  },
+  // infrastructure and cloud
+  (w, raw) => {
+    const s = raw.toLowerCase();
+    const hit = /\b(terraform|tofu|terragrunt)\s+(destroy|apply\b.*-destroy)/.test(s) && "tears down infrastructure" || /\bpulumi\s+(destroy|down)\b/.test(s) && "tears down infrastructure" || /\bcdk\s+destroy\b/.test(s) && "tears down infrastructure" || /\bkubectl\s+delete\b.*(\b(ns|namespace|namespaces|pv|pvc|node)\b|--all\b)/.test(s) && "deletes Kubernetes resources broadly" || /\bhelm\s+(uninstall|delete)\b/.test(s) && "removes a Helm release" || /\bdocker\s+(system\s+prune\b.*(-a|--all|--volumes)|volume\s+(rm|prune)\b|compose\s+down\b.*(-v|--volumes))/.test(s) && "deletes Docker volumes or all unused data" || /\baws\s+s3\s+(rm\b.*--recursive|rb\b)/.test(s) && "deletes S3 objects or a bucket" || /\baws\s+\S+\s+(delete|terminate)-/.test(s) && "deletes AWS resources" || /\bgcloud\b.*\b(delete)\b/.test(s) && "deletes Google Cloud resources" || /\baz\s+\S+.*\bdelete\b/.test(s) && "deletes Azure resources" || /\b(vercel|netlify|fly|flyctl|railway|heroku)\b.*\b(remove|rm|destroy|delete|apps:destroy)\b/.test(s) && "deletes a deployment or app";
+    return hit ? { decision: "ask", reason: `"${raw.trim().slice(0, 200)}" ${hit}. Confirm with the user first.` } : null;
+  }
+];
+function exfiltration(line) {
+  const s = line.toLowerCase();
+  const net = /\b(curl|wget|nc|ncat|netcat|socat|http|httpie|scp|rsync|ftp|telnet)\b/;
+  const secret = /(\.env\b|\.ssh\/|id_rsa|id_ed25519|\.aws\/credentials|\.npmrc|\.netrc|\.pgpass|\.git-credentials|\.docker\/config\.json|\bprintenv\b|(^|[|;&\s])env(\s*[|;&]|\s*$))/;
+  if (!net.test(s) || !secret.test(s)) return null;
+  const piped = /\|\s*(curl|wget|nc|ncat|netcat|socat|http)\b/.test(s);
+  const uploaded = /(\s-d|--data(-binary|-raw)?|\s-F|--form|\s-T|--upload-file)\s+\S*@\S*(\.env|\.ssh|id_rsa|credentials|\.npmrc|\.netrc)/.test(line) || /\b(scp|rsync)\b.*(\.env|\.ssh|id_rsa|credentials)/.test(s);
+  return piped || uploaded ? { decision: "deny", reason: "This sends secrets (.env, SSH keys, cloud credentials or the environment) over the network." } : null;
+}
+function destructiveVerdict(line, opts = {}) {
+  const home = normalize(opts.home ?? homedir2());
+  const cwd = normalize(opts.cwd ?? process.cwd());
+  const ctx = { cwd, home, project: normalize(opts.project ?? cwd), env: opts.env ?? process.env };
+  if (ctx.project === home || SYSTEM_DIRS.includes(ctx.project)) ctx.project = join3(home, "\0no-project");
+  const verdicts = [exfiltration(line), /:\(\)\s*\{\s*:\s*\|\s*:\s*&\s*\}\s*;\s*:/.test(line) ? { decision: "deny", reason: "Fork bomb." } : null];
+  for (const { raw, words } of split(line)) {
+    const w = strip(words);
+    if (!w.length) continue;
+    for (const rule of RULES) verdicts.push(rule(w, raw, ctx));
+  }
+  const hits = verdicts.filter((v) => !!v);
+  if (!hits.length) return null;
+  const deny = hits.filter((v) => v.decision === "deny");
+  const pick = deny.length ? deny : hits;
+  return { decision: deny.length ? "deny" : "ask", reason: [...new Set(pick.map((v) => v.reason))].join("\n") };
+}
+
+// src/guard.ts
+function commands(line) {
+  return line.split(/&&|\|\||[;|\n]/).map((c) => (c.match(/"[^"]*"|'[^']*'|\S+/g) ?? []).map((w) => w.replace(/^["']|["']$/g, ""))).filter((w) => w.length);
+}
+var VALUE_FLAGS = /* @__PURE__ */ new Set(["-r", "--requirement", "-c", "--constraint", "-e", "--editable", "-i", "--index-url", "--extra-index-url", "-f", "--find-links", "--registry", "--tag", "--filter", "-w", "--workspace", "--cwd", "--prefix", "-C", "--dir", "--python", "-p", "--group", "-G", "--source", "--features", "-F", "--package", "--with"]);
+function args(words) {
+  const out = [];
+  for (let i = 0; i < words.length; i++) {
+    const w = words[i];
+    if (w.startsWith("-")) {
+      if (VALUE_FLAGS.has(w)) i++;
+      continue;
+    }
+    out.push(w);
+  }
+  return out;
+}
+var isLocalOrUrl = (s) => /^(\.{0,2}\/|~|file:|git[+:]|https?:|github:|link:|workspace:)/.test(s) || /\.(tgz|tar\.gz|whl|zip)$/.test(s);
+function npmSpec(s) {
+  if (isLocalOrUrl(s) || /^[\w.-]+\/[\w.-]+$/.test(s)) return null;
+  const m = s.match(/^(@[^/@\s]+\/[^@\s]+|[^@\s]+)(?:@(.+))?$/);
+  if (!m || !/^(@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/i.test(m[1])) return null;
+  const version = m[2] && /\d/.test(m[2]) ? m[2] : void 0;
+  return { name: m[1], ecosystem: "npm", ...version ? { version } : {} };
+}
+function pySpec(s) {
+  if (isLocalOrUrl(s)) return null;
+  const m = s.match(/^([A-Za-z0-9][A-Za-z0-9._-]*)(?:\[[^\]]*\])?\s*(?:(==|~=|>=|<=|>|<|!=)\s*([^,;\s]+))?/);
+  if (!m) return null;
+  return { name: m[1], ecosystem: "pypi", ...m[3] ? { version: m[3] } : {} };
+}
+function cargoSpec(s) {
+  const m = s.match(/^([A-Za-z0-9_-]+)(?:@(.+))?$/);
+  return m ? { name: m[1], ecosystem: "cargo", ...m[2] ? { version: m[2] } : {} } : null;
+}
+function goSpec(s) {
+  const m = s.match(/^([a-z0-9.-]+\.[a-z]{2,}\/[^@\s]+?)(?:\/\.\.\.)?(?:@(.+))?$/i);
+  if (!m) return null;
+  const version = m[2] && /^v\d/.test(m[2]) ? m[2] : void 0;
+  return { name: m[1], ecosystem: "go", ...version ? { version } : {} };
+}
+function packagesInCommand(line) {
+  const out = [];
+  for (let words of commands(line)) {
+    while (words.length && /^(sudo|env|\w+=\S*|time|nice|command)$/.test(words[0])) words = words.slice(1);
+    const [tool, sub, ...rest] = words;
+    if (!tool) continue;
+    const bin = tool.split("/").pop();
+    let specs = [];
+    if (bin === "npm" && ["install", "i", "add", "in", "isntall"].includes(sub)) specs = args(rest).map(npmSpec);
+    else if (bin === "pnpm" && ["add", "install", "i"].includes(sub)) specs = args(rest).map(npmSpec);
+    else if (bin === "yarn" && sub === "add") specs = args(rest).map(npmSpec);
+    else if (bin === "bun" && ["add", "install", "i"].includes(sub)) specs = args(rest).map(npmSpec);
+    else if (["npx", "bunx"].includes(bin)) specs = [npmSpec(args([sub, ...rest].filter(Boolean))[0] ?? "")];
+    else if ((bin === "pnpm" || bin === "yarn") && sub === "dlx") specs = [npmSpec(args(rest)[0] ?? "")];
+    else if (/^pip3?$/.test(bin) && sub === "install") specs = args(rest).map(pySpec);
+    else if (/^python3?$/.test(bin) && sub === "-m" && /^pip3?$/.test(rest[0] ?? "") && rest[1] === "install") specs = args(rest.slice(2)).map(pySpec);
+    else if (bin === "uv" && sub === "add") specs = args(rest).map(pySpec);
+    else if (bin === "uv" && sub === "pip" && rest[0] === "install") specs = args(rest.slice(1)).map(pySpec);
+    else if (bin === "uv" && sub === "tool" && rest[0] === "install") specs = args(rest.slice(1)).map(pySpec);
+    else if (bin === "uvx" || bin === "pipx" && sub === "run") specs = [pySpec(args(bin === "uvx" ? [sub, ...rest].filter(Boolean) : rest)[0] ?? "")];
+    else if (bin === "pipx" && sub === "install") specs = args(rest).map(pySpec);
+    else if (bin === "poetry" && sub === "add") specs = args(rest).map(pySpec);
+    else if (bin === "cargo" && (sub === "add" || sub === "install")) specs = args(rest).map(cargoSpec);
+    else if (bin === "go" && (sub === "get" || sub === "install")) specs = args(rest).map(goSpec);
+    for (const s of specs) if (s) out.push(s);
+  }
+  const seen = /* @__PURE__ */ new Set();
+  return out.filter((p) => !seen.has(`${p.ecosystem}:${p.name}`) && !!seen.add(`${p.ecosystem}:${p.name}`)).slice(0, 25);
+}
+async function readStdin() {
+  const chunks = [];
+  for await (const c of process.stdin) chunks.push(c);
+  return Buffer.concat(chunks).toString("utf8");
+}
+async function runGuard(opts) {
+  let command = "";
+  let cwd;
+  try {
+    const payload = JSON.parse(await readStdin());
+    command = payload.tool_input?.command ?? "";
+    cwd = payload.cwd;
+  } catch {
+    return 0;
+  }
+  const local = destructiveVerdict(command, { cwd, project: cwd });
+  const packages = packagesInCommand(command);
+  if (local?.decision === "deny" || !packages.length) return emit(local);
+  if (!opts.key) {
+    console.error("codexguild guard: CODEXGUILD_API_KEY is not set \u2014 packages were not checked.");
+    return emit(local);
+  }
+  let results;
+  try {
+    const res = await fetch(`${opts.api}/packages/check`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", Authorization: `Bearer ${opts.key}` },
+      body: JSON.stringify({ packages }),
+      signal: AbortSignal.timeout(15e3)
+    });
+    if (!res.ok) throw new Error(`HTTP ${res.status}`);
+    results = (await res.json()).results;
+  } catch (e) {
+    console.error(`codexguild guard: check failed (${e instanceof Error ? e.message : e}) \u2014 command not blocked.`);
+    return emit(local);
+  }
+  return emit(mergeVerdicts(local, guardDecision(results)));
+}
+function mergeVerdicts(a, b) {
+  if (!a || !b) return a ?? b;
+  if (a.decision !== b.decision) return a.decision === "deny" ? a : b;
+  return { decision: a.decision, reason: `${a.reason}
+${b.reason}` };
+}
+function emit(d) {
+  if (d) process.stdout.write(JSON.stringify({ hookSpecificOutput: { hookEventName: "PreToolUse", permissionDecision: d.decision, permissionDecisionReason: `CodexGuild guard: ${d.reason}` } }));
+  return 0;
+}
+function guardDecision(results) {
+  const flagged = results.filter((r) => r.verdict === "block" || r.verdict === "warn");
+  if (!flagged.length) return null;
+  const lines = flagged.map((r) => `${r.verdict === "block" ? "BLOCKED" : "Check"} ${r.ecosystem}:${r.name}${r.version ? `@${r.version}` : ""} \u2014 ${r.reasons.join(" ")}`);
+  const blocked = flagged.some((r) => r.verdict === "block");
+  return {
+    decision: blocked ? "deny" : "ask",
+    reason: `package check:
+${lines.join("\n")}${blocked ? "\nUse the correct package name, or ask the user before trying again." : ""}`
+  };
+}
+
 // src/index.ts
 var API = (process.env.CODEXGUILD_API_URL || "https://api.codexguild.com/v1").replace(/\/$/, "");
 var KEY = process.env.CODEXGUILD_API_KEY ?? "";
-var VERSION = "1.1.0";
+var VERSION = "1.5.0";
+if (process.argv[2] === "guard") process.exit(await runGuard({ api: API, key: KEY }));
 var INSTRUCTION_FILES = ["CLAUDE.md", ".claude/CLAUDE.md", "AGENTS.md", "AGENTS.override.md", ".hermes.md", "HERMES.md", "GEMINI.md", ".cursorrules"];
 async function existingInstructionFiles(cwd) {
-  const present = await Promise.all(INSTRUCTION_FILES.map((f) => access(join3(cwd, f)).then(() => f, () => null)));
+  const present = await Promise.all(INSTRUCTION_FILES.map((f) => access(join4(cwd, f)).then(() => f, () => null)));
   return present.filter((f) => f !== null);
 }
 var remote = null;
@@ -646,7 +1410,8 @@ var SCAN_TOOL = {
 };
 var ENHANCED = {
   codexguild_sync: "Runs locally first: the stack (package.json, requirements.txt, go.mod, \u2026) and installed skill NAMES are detected automatically \u2014 only names/versions are sent, never file contents; you only need force/since.",
-  codexguild_advise: "Runs locally first: stack, installed skills and the instruction files present in the project are detected automatically; you only need harness."
+  codexguild_advise: "Runs locally first: stack, installed skills and the instruction files present in the project are detected automatically; you only need harness.",
+  codexguild_debug: "Runs locally first: the project's package versions are read from its lockfiles and sent with the error \u2014 you only need error (and stack)."
 };
 function enhance(t) {
   const note = ENHANCED[t.name];
@@ -662,47 +1427,141 @@ ${note}`,
   };
 }
 async function detected(name, cwd) {
-  const [{ deps, manifests }, local] = await Promise.all([detectStack(cwd), scanLocalSkills()]);
+  if (name === "codexguild_debug") {
+    const { deps: deps2 } = await detectStack(cwd);
+    return { args: { packages: deps2.slice(0, 300).map((d) => ({ name: d.name, ...d.version ? { version: d.version } : {}, ...d.ecosystem ? { ecosystem: d.ecosystem } : {} })) } };
+  }
+  const [{ deps, manifests, lockfiles, exact, ranges }, local, project] = await Promise.all([detectStack(cwd), scanLocalSkills(), projectKey(cwd)]);
   const installedSkills = await installedSkillNames(local.reports.map((r) => r.dir));
   if (name === "codexguild_advise") {
-    return { args: { stack: deps, installedSkills, existingInstructionFiles: await existingInstructionFiles(cwd) } };
+    return { args: { stack: deps, installedSkills, existingInstructionFiles: await existingInstructionFiles(cwd), project } };
   }
   const flagged = local.reports.filter((x) => x.result.status === "flagged");
+  const shown = (xs) => xs.length > 8 ? `${xs.slice(0, 8).join(", ")} +${xs.length - 8} more` : xs.join(", ");
   const summary = [
-    `Detected ${deps.length} dependencies from ${manifests.join(", ") || "no manifest"}.`,
+    `Project ${project}: ${deps.length} dependencies from ${shown(manifests) || "no manifest"} \u2014 ${exact} exact${lockfiles.length ? ` (lockfiles: ${shown(lockfiles)})` : ""}, ${ranges} ranges${ranges ? " (no lockfile entry; reported as ranges, not exact versions)" : ""}.`,
     `Local skill scan: ${local.reports.length} skills \u2014 ${flagged.length} flagged, ${local.reports.filter((x) => x.result.status === "warn").length} to review.`,
     ...flagged.slice(0, 10).map((x) => `  - FLAGGED ${x.dir}: ${x.result.findings[0]?.title ?? ""}`),
     ...flagged.length ? ["  Run codexguild_scan_skills for details and ask the user before using flagged skills."] : []
   ].join("\n");
-  return { args: { stack: deps, installedSkills }, summary };
+  return { args: { stack: deps, installedSkills, project }, summary };
+}
+var LINT_TOOL = {
+  name: "codexguild_lint_instructions",
+  description: "Lint the agent instruction files in this project (AGENTS.md, CLAUDE.md, GEMINI.md, .cursorrules\u2026): size per session, missing build/test commands, README copy, generic advice, secrets, machine-specific paths, prompt-injection and other scanner findings. Runs locally \u2014 file contents are not uploaded.",
+  inputSchema: {
+    type: "object",
+    properties: { files: { type: "array", items: { type: "string" }, description: "Paths to lint instead of the instruction files found in the project root" } }
+  }
+};
+async function lintLocal(cwd, files) {
+  const targets = files?.length ? files : await existingInstructionFiles(cwd);
+  if (!targets.length) return "No instruction files found (looked for CLAUDE.md, AGENTS.md, GEMINI.md, .cursorrules, \u2026).";
+  const out = [];
+  for (const f of targets) {
+    const content = await readFile3(isAbsolute2(f) ? f : join4(cwd, f), "utf8").catch(() => null);
+    if (content === null) {
+      out.push(`## ${f}
+Could not read the file.`);
+      continue;
+    }
+    const r = lintInstructions(content, f.split("/").pop());
+    out.push(`## ${f} \u2014 ${r.score}/100 (${r.grade}) \xB7 ~${r.stats.approxTokens} tokens \xB7 ${r.stats.commands} commands`);
+    out.push(...r.issues.length ? r.issues.slice(0, 25).map((i) => `- [${i.severity}]${i.line ? ` line ${i.line}` : ""} ${i.title}: ${i.detail}`) : ["- No issues."]);
+  }
+  return out.join("\n");
 }
 var text = (t, isError = false) => ({ content: [{ type: "text", text: t }], ...isError ? { isError } : {} });
-var server = new Server({ name: "codexguild", version: VERSION }, { capabilities: { tools: {} } });
+var server = new Server({ name: "codexguild", version: VERSION }, { capabilities: { tools: { listChanged: true } } });
+var WORKFLOWS_TOOL = {
+  name: "codexguild_scan_workflows",
+  description: "Security-review the GitHub Actions workflows in this project that run coding agents (claude-code-action, run-gemini-cli, codex, opencode, aider\u2026): triggers outside contributors control (pull_request_target, issue_comment, issues) combined with secrets, issue/PR text interpolated into prompts or shells (prompt injection), unrestricted agent tools, broad permissions, unpinned agent actions. Runs locally \u2014 nothing is uploaded.",
+  inputSchema: {
+    type: "object",
+    properties: { files: { type: "array", items: { type: "string" }, description: "Workflow files to review instead of .github/workflows/*.yml" } }
+  },
+  annotations: { readOnlyHint: true, openWorldHint: false }
+};
+async function scanWorkflowsLocal(cwd, files) {
+  const dir = join4(cwd, ".github", "workflows");
+  const targets = files?.length ? files : (await readdir3(dir).catch(() => [])).filter((f) => /\.ya?ml$/.test(f)).map((f) => join4(dir, f));
+  if (!targets.length) return "No workflows found in .github/workflows.";
+  const out = [];
+  for (const f of targets) {
+    const content = await readFile3(isAbsolute2(f) ? f : join4(cwd, f), "utf8").catch(() => null);
+    const name = f.startsWith(cwd + "/") ? f.slice(cwd.length + 1) : f;
+    if (content === null) {
+      out.push(`## ${name}
+Could not read the file.`);
+      continue;
+    }
+    const r = lintWorkflow(content);
+    if (!r.agents.length && !r.issues.length) continue;
+    out.push(`## ${name} \u2014 ${r.score}/100 (${r.grade})${r.agents.length ? ` \xB7 runs ${r.agents.join(", ")}` : ""}${r.untrustedTriggers.length ? ` \xB7 untrusted triggers: ${r.untrustedTriggers.join(", ")}` : ""}`);
+    out.push(...r.issues.length ? r.issues.map((i) => `- [${i.severity}]${i.line ? ` line ${i.line}` : ""} ${i.title}: ${i.detail}`) : ["- No issues."]);
+  }
+  return out.length ? out.join("\n") : `Reviewed ${targets.length} workflow(s): none runs a coding agent and no injection risks were found.`;
+}
+var LOCAL_TOOLS = [SCAN_TOOL, LINT_TOOL, WORKFLOWS_TOOL];
+var RETRY_MS = [1e3, 3e3];
+var RECONNECT_MS = 3e4;
+var reconnectTimer = null;
+async function remoteTools() {
+  for (let attempt = 0; ; attempt++) {
+    try {
+      return (await (await remoteClient()).listTools()).tools;
+    } catch (e) {
+      if (!KEY || attempt >= RETRY_MS.length) throw e;
+      await new Promise((r) => setTimeout(r, RETRY_MS[attempt]));
+    }
+  }
+}
+function scheduleReconnect() {
+  if (reconnectTimer || !KEY) return;
+  reconnectTimer = setInterval(async () => {
+    try {
+      await (await remoteClient()).listTools();
+      clearInterval(reconnectTimer);
+      reconnectTimer = null;
+      console.error("CodexGuild: remote endpoint reachable again \u2014 tool list updated.");
+      await server.sendToolListChanged();
+    } catch {
+    }
+  }, RECONNECT_MS);
+  reconnectTimer.unref();
+}
 server.setRequestHandler(ListToolsRequestSchema, async () => {
   try {
-    const { tools } = await (await remoteClient()).listTools();
-    return { tools: [SCAN_TOOL, ...tools.map(enhance)] };
-  } catch {
-    return { tools: [SCAN_TOOL] };
+    return { tools: [...LOCAL_TOOLS, ...(await remoteTools()).map(enhance)] };
+  } catch (e) {
+    console.error(`CodexGuild: remote tools unavailable (${e instanceof Error ? e.message : String(e)}) \u2014 serving local tools only; retrying in the background.`);
+    scheduleReconnect();
+    return { tools: LOCAL_TOOLS };
   }
 });
 server.setRequestHandler(CallToolRequestSchema, async (req) => {
   const { name } = req.params;
-  const args = { ...req.params.arguments ?? {} };
+  const args2 = { ...req.params.arguments ?? {} };
   try {
+    if (name === WORKFLOWS_TOOL.name) {
+      return text(await scanWorkflowsLocal(process.cwd(), Array.isArray(args2.files) ? args2.files.map(String) : void 0));
+    }
+    if (name === LINT_TOOL.name) {
+      return text(await lintLocal(process.cwd(), Array.isArray(args2.files) ? args2.files.map(String) : void 0));
+    }
     if (name === SCAN_TOOL.name) {
-      const paths = Array.isArray(args.paths) ? args.paths.map(String) : void 0;
-      return text(formatLocalScan(await scanLocalSkills(paths), args.verbose === true));
+      const paths = Array.isArray(args2.paths) ? args2.paths.map(String) : void 0;
+      return text(formatLocalScan(await scanLocalSkills(paths), args2.verbose === true));
     }
     let summary;
     if (name in ENHANCED) {
-      const cwd = typeof args.cwd === "string" ? args.cwd : process.cwd();
-      delete args.cwd;
+      const cwd = typeof args2.cwd === "string" ? args2.cwd : process.cwd();
+      delete args2.cwd;
       const d = await detected(name, cwd);
       summary = d.summary;
-      Object.assign(args, { ...d.args, ...args });
+      Object.assign(args2, { ...d.args, ...args2 });
     }
-    const r = await (await remoteClient()).callTool({ name, arguments: args });
+    const r = await (await remoteClient()).callTool({ name, arguments: args2 });
     return summary ? { ...r, content: [{ type: "text", text: summary }, ...r.content ?? []] } : r;
   } catch (e) {
     return text(`CodexGuild error: ${e instanceof Error ? e.message : String(e)}`, true);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@codexguild/mcp",
-  "version": "1.1.0",
-  "description": "CodexGuild MCP server (stdio) — forwards to the remote CodexGuild MCP endpoint and adds local stack detection and an offline security audit of installed agent skills",
+  "version": "1.5.0",
+  "description": "CodexGuild MCP server (stdio) \u2014 forwards to the remote CodexGuild MCP endpoint and adds local stack detection and an offline security audit of installed agent skills",
   "keywords": [
     "mcp",
     "model-context-protocol",
@@ -39,10 +39,11 @@
     "build": "tsc -p tsconfig.json --noEmit && esbuild src/index.ts --bundle --platform=node --format=esm --target=node20 --packages=external --alias:@codexguild/scanner=../scanner/src/index.ts --outfile=dist/codexguild-mcp.js",
     "start": "node dist/codexguild-mcp.js",
     "dev": "tsx src/index.ts",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "npm run build",
+    "test": "node --import tsx --test test/*.test.mjs"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.12.0"
+    "@modelcontextprotocol/sdk": "^1.32.1"
   },
   "devDependencies": {
     "@types/node": "^22.10.0",