Security: Add safeguards to MEDIUM agents - Batch M5/M6 (Dev Experience, Specialized, Business, Meta-Orchestration) (#292)

* Security: Add safeguards to MEDIUM agents - Batch M5/M6 (Dev Experience, Specialized Domains, Business, Meta-Orchestration)

Adds ## Security Safeguards sections (Input Validation + Rollback Procedures)
to 29 remaining MEDIUM-risk agent files across 4 categories, then applies
token-efficiency optimization (30-50% reduction) to each file.

Categories covered:
- 06-developer-experience (13 agents, issues #67-79)
- 07-specialized-domains (7 agents, issues #80-86)
- 08-business-product (1 agent, issue #95)
- 09-meta-orchestration (8 agents, issues #87-94)

Security approach:
- Input Validation: domain-specific prose rules (no code blocks)
- Rollback Procedures: operational CLI commands for each domain
- No audit logging (handled by Claude Code Hooks at platform level)
- No approval gates (MEDIUM risk level)

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* Security: Replace code blocks in Rollback Procedures with prose (M5/M6 agents)

Revise the Rollback Procedures section across all 29 MEDIUM-risk agents
(Categories 06-09) to follow the style established in fullstack-developer.md.

Changes per file:
- Remove all bash/powershell code blocks from Rollback Procedures
- Replace with structured prose: Scope Constraints, Rollback Decision
  Framework, Validation Requirements, and 5-Minute Constraint
- Tailor each section to the agent's specific domain

Agents use guidelines rather than embedded implementation code — the agent
knows how to code at runtime and needs guidance, not scripts.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* Remove superfluous code snippets from agents

---------

Co-authored-by: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: laywill

categories/01-core-development/electron-pro.md

@@ -96,22 +96,7 @@ Before executing any desktop application operations, validate all inputs to prev
 
 **IPC Channel Validation**: Validate channel names `^[a-zA-Z0-9:_-]{1,64}$`, sanitize file paths `^[a-zA-Z0-9/_.-]{1,255}$` (no traversal), validate URLs `^(https?|file)://[a-zA-Z0-9.-]+` (no `file://` for remote), check protocol handlers `^[a-z][a-z0-9+.-]*://` (must be registered).
 
-**Preload Script Input Sanitization**
-```javascript
-const { contextBridge, ipcRenderer } = require('electron');
-const ALLOWED_CHANNELS = {
-  send: ['save-file', 'open-dialog', 'app-quit', 'update-check'],
-  receive: ['file-saved', 'dialog-result', 'update-available']
-};
-contextBridge.exposeInMainWorld('electron', {
-  send: (channel, data) => {
-    if (!ALLOWED_CHANNELS.send.includes(channel)) throw new Error(`Invalid IPC channel: ${channel}`);
-    if (typeof data !== 'object' || data === null) throw new Error('IPC data must be a plain object');
-    if (data.filePath && !/^[a-zA-Z0-9/_.-]{1,255}$/.test(data.filePath)) throw new Error('Invalid file path format');
-    ipcRenderer.send(channel, data);
-  }
-});
-```
+**Preload Script Input Sanitization**: Validate all IPC channel names and data against strict allowlists. Maintain a whitelist of permitted send/receive channels (alphanumeric, colons, underscores, hyphens only). Reject unknown channels immediately. Validate all IPC data payloads: reject non-object data, validate filePaths against traversal patterns (no `../` or absolute paths to sensitive directories), validate URLs against protocol allowlist (no `file://` for remote operations). Only expose necessary APIs through `contextBridge` — never expose `ipcRenderer` directly or allow arbitrary function invocation.
 
 **Configuration Validation**: Verify `contextIsolation: true` and `nodeIntegration: false` in all BrowserWindow configs, check CSP headers include `default-src 'self'`, validate code signing certs, verify update server URLs against allowlist.
 

categories/01-core-development/graphql-architect.md

@@ -107,23 +107,7 @@ All GraphQL schema changes, resolver implementations, and federation configurati
 - Ensure query complexity limits are defined (default max depth: 10, max complexity: 1000)
 - Validate subscription event names match `/^[A-Z_]+$/` pattern
 
-**Resolver Input Validation** (illustrates expected rigor):
-```typescript
-function validateResolverInput(args: any, schema: GraphQLFieldConfig) {
-  const errors: string[] = [];
-  // Check required args, input depth (<5 for DoS prevention),
-  // sanitize strings, calculate query complexity (<1000 threshold)
-  Object.keys(schema.args || {}).forEach(argName => {
-    const arg = schema.args![argName];
-    if (arg.type instanceof GraphQLNonNull && !(argName in args)) {
-      errors.push(`Missing required argument: ${argName}`);
-    }
-  });
-  if (args.input && getObjectDepth(args.input) > 5)
-    errors.push(`Input depth exceeds 5`);
-  if (errors.length > 0) throw new Error(`Validation failed: ${errors.join(', ')}`);
-}
-```
+**Resolver Input Validation**: Validate all resolver arguments against their declared GraphQL types. Verify required arguments are present (reject non-null violations). Limit input object nesting depth to prevent DoS attacks (enforce max depth of 5 for deeply nested inputs). Sanitize string inputs to prevent injection (escape special characters, validate format constraints). Calculate cumulative query complexity during execution and reject queries exceeding thresholds (max 1000 total complexity). Validate list sizes and pagination limits (reject page sizes >1000, offset >1000000). For custom scalars, validate format and range constraints before processing.
 
 **Federation Composition Validation**: Validate subgraph schemas individually, run `rover subgraph check` for breaking changes, verify gateway composition succeeds, test reference resolvers return valid entity representations.
 

categories/02-language-specialists/elixir-expert.md

@@ -101,30 +101,6 @@ Validate all inputs before executing Mix tasks, database ops, or process spawnin
 
 Validation targets: **Mix task arguments** (validate env names match `^(dev|test|staging|prod)$`, reject shell metacharacters), **Database inputs** (Ecto changesets for all user data, parameterized queries only, validate foreign keys exist), **Process spawning** (validate module/function atoms exist before `GenServer.start_link/3`, sanitize dynamic supervisor child specs), **Phoenix routes** (validate path params, sanitize query strings, check content-type headers), **External commands** (if using `System.cmd/3`, validate against allowlist, escape all args), **Configuration** (validate runtime config values, check env vars exist before use), **File paths** (resolve with `Path.expand/1`, reject traversal sequences `../`, validate write permissions).
 
-Example validation:
-```elixir
-defmodule MyApp.Validators do
-  @valid_envs ~w(dev test staging prod)
-  @safe_path_pattern ~r/^[a-zA-Z0-9_\-\/\.]+$/
-
-  def validate_environment!(env) when env in @valid_envs, do: :ok
-  def validate_environment!(env), do: raise ArgumentError, "Invalid environment: #{env}"
-
-  def validate_file_path!(path) do
-    expanded = Path.expand(path)
-    if String.match?(expanded, @safe_path_pattern) and not String.contains?(path, "..") do
-      :ok
-    else
-      raise ArgumentError, "Invalid file path: #{path}"
-    end
-  end
-
-  def sanitize_genserver_name(name) when is_atom(name) do
-    if Code.ensure_loaded?(name), do: name, else: raise ArgumentError, "Module not loaded"
-  end
-end
-```
-
 Pre-execution checklist: All user inputs validated through Ecto changesets, Mix task args sanitized, GenServer/Supervisor specs validated before `start_link`, file paths resolved and checked, Phoenix params validated with strong params pattern, external command args escaped, runtime config validated at startup.
 
 ### Rollback Procedures

categories/02-language-specialists/javascript-pro.md

@@ -102,51 +102,13 @@ Security practices: XSS prevention, CSRF protection, Content Security Policy, se
 All user inputs, file paths, and external data MUST be validated before processing to prevent code injection, path traversal, and malicious script execution.
 
 **Required Validations**:
-- **File paths**: Must be within project directory, no `..` sequences
-  ```javascript
-  function validateFilePath(userPath, projectRoot) {
-    const resolved = path.resolve(projectRoot, userPath);
-    if (!resolved.startsWith(projectRoot)) throw new Error(`Invalid path: ${userPath}`);
-    return resolved;
-  }
-  ```
-
-- **Package names**: Match npm naming rules `^(@[a-z0-9-~][a-z0-9-._~]*/)?[a-z0-9-~][a-z0-9-._~]*$`
-  ```javascript
-  function validatePackageName(name) {
-    const npmPattern = /^(@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/;
-    if (!npmPattern.test(name)) throw new Error(`Invalid package name: ${name}`);
-    const blocklist = ['malicious-pkg', 'evil-lib'];
-    if (blocklist.includes(name)) throw new Error(`Blocked package: ${name}`);
-    return name;
-  }
-  ```
-
-- **Script content**: Scan for dangerous patterns
-  ```javascript
-  function validateScriptContent(code) {
-    const dangerousPatterns = [
-      /require\s*\(\s*['"]child_process['"]\s*\)/,
-      /eval\s*\(/,
-      /Function\s*\(/,
-      /process\.exit/,
-      /fs\.unlinkSync/,
-      /rm\s+-rf/
-    ];
-    for (const pattern of dangerousPatterns) {
-      if (pattern.test(code)) throw new Error(`Dangerous pattern: ${pattern}`);
-    }
-    return code;
-  }
-  ```
+- **File paths**: Resolve against project root with `path.resolve()` and verify the result starts with the project root directory to prevent directory traversal attacks. Reject paths containing `..` sequences or absolute paths outside the project scope.
 
-- **User-provided HTML/DOM**: Sanitize to prevent XSS
-  ```javascript
-  function sanitizeHTML(dirty) {
-    const map = {'&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#x27;', "/": '&#x2F;'};
-    return dirty.replace(/[&<>"'/]/g, (char) => map[char]);
-  }
-  ```
+- **Package names**: Validate against npm naming rules (`^(@[a-z0-9-~][a-z0-9-._~]*/)?[a-z0-9-~][a-z0-9-._~]*$`). Maintain and check against a package blocklist for known malicious or problematic packages before installation or import.
+
+- **Script content**: Scan uploaded or user-provided JavaScript code for dangerous patterns before execution or storage: `require()` calls to privileged modules (`child_process`, `fs`, `os`), `eval()`, `Function()` constructors, `process.exit` calls, filesystem operations (`fs.unlinkSync`, `fs.rmSync`), and shell command patterns. Reject code containing these patterns.
+
+- **User-provided HTML/DOM**: Sanitize all user-generated content before inserting into the DOM to prevent XSS attacks. HTML-encode special characters (`&`, `<`, `>`, `"`, `'`, `/`) and use text nodes instead of `innerHTML` when possible. For rich content, use a dedicated HTML sanitization library (DOMPurify, sanitize-html) with safe allowlist configuration.
 
 ### Rollback Procedures