pi-squad 0.7.2 → 0.15.0

package/package.json

@@ -1,8 +1,11 @@
 {
   "name": "pi-squad",
-  "version": "0.7.2",
+  "version": "0.15.0",
   "description": "Multi-agent collaboration extension for pi — task decomposition, dependency management, parallel execution, TUI panel",
   "type": "module",
+  "scripts": {
+    "test": "node --test tests/*.test.mjs"
+  },
   "pi": {
     "extensions": [
       "src/index.ts"
@@ -10,6 +13,8 @@
     "skills": [
       "src/skills/squad-supervisor",
       "src/skills/squad-backend-dev",
+      "src/skills/squad-code-review",
+      "src/skills/squad-debugging",
       "src/skills/squad-frontend-dev",
       "src/skills/squad-qa-testing",
       "src/skills/squad-security-audit",
@@ -22,6 +27,7 @@
     "LICENSE"
   ],
   "keywords": [
+    "pi-package",
     "pi",
     "pi-extension",
     "multi-agent",
@@ -35,5 +41,15 @@
     "type": "git",
     "url": "https://github.com/picassio/pi-squad.git"
   },
-  "homepage": "https://github.com/picassio/pi-squad"
+  "homepage": "https://github.com/picassio/pi-squad#readme",
+  "bugs": {
+    "url": "https://github.com/picassio/pi-squad/issues"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "devDependencies": {
+    "@types/node": "^26.1.1"
+  }
 }

package/src/advisor.ts

@@ -0,0 +1,145 @@
+/**
+ * advisor.ts — Squad advisor: consult a stronger model when an agent is stuck.
+ *
+ * Modeled on the advisor tool pattern (pi-advisor / Anthropic's advisor
+ * strategy): the agent keeps doing the work; when the Monitor detects it is
+ * stuck, looping, or timing out, the squad consults an advisor model with a
+ * curated context digest and steers the agent with the returned verdict +
+ * action items. Escalation to the human happens only when the advisor is
+ * disabled, exhausted, or fails.
+ *
+ * This module is pure (no pi imports) so it stays unit-testable.
+ */
+
+import type { Task, TaskMessage } from "./types.js";
+
+// ============================================================================
+// Settings
+// ============================================================================
+
+export interface AdvisorSettings {
+	/** Consult an advisor before escalating stuck agents to the human */
+	enabled: boolean;
+	/** "main" = main session's current model, or an explicit "provider/id" */
+	model: string;
+	/** Max advisor consultations per task before escalating for real */
+	maxCallsPerTask: number;
+	/** Max output tokens per advisor call (thinking tokens count on adaptive models) */
+	maxTokens: number;
+	/** Reasoning effort for the advisor call */
+	reasoning: string;
+}
+
+export const DEFAULT_ADVISOR_SETTINGS: AdvisorSettings = {
+	enabled: true,
+	model: "main",
+	maxCallsPerTask: 2,
+	maxTokens: 8192,
+	reasoning: "medium",
+};
+
+// ============================================================================
+// Consult input/output
+// ============================================================================
+
+export interface AdvisorConsultInput {
+	taskId: string;
+	taskTitle: string;
+	taskDescription: string;
+	agentName: string;
+	agentRole: string;
+	/** Why the monitor flagged this agent (stuck, looping, timeout...) */
+	reason: string;
+	/** Recent task messages (already tailed by the caller) */
+	recentMessages: Pick<TaskMessage, "from" | "type" | "text">[];
+	/** Recent tool call summaries from agent activity */
+	recentToolCalls: string[];
+	turnCount: number;
+	elapsedMinutes: number;
+}
+
+// ============================================================================
+// Prompts
+// ============================================================================
+
+export const ADVISOR_SYSTEM_PROMPT = `You are a senior engineering advisor for an autonomous squad agent that has run into trouble. The agent works on one task inside a multi-agent squad; a monitor flagged it (stuck, looping, or idle) and you are consulted before the problem is escalated to a human.
+
+Your role:
+- You see a curated digest: the task, recent messages, and recent tool activity summaries — not the full transcript
+- If the evidence is too thin to judge, say so — never fill gaps with guesses
+- You cannot call tools. Your advice is injected directly into the agent's conversation as a steering message and it will act on it immediately
+
+Output format:
+- Lead with a one-sentence verdict: "Course-correct", "Push through", or "Needs human input"
+- Follow with numbered action items (max 5) the agent should take next
+- If the evidence doesn't settle a point, make your FIRST action item the exact command or file read that would settle it — instead of guessing
+- Reference specific files, commands, or error signals from the digest
+- If the blocker genuinely requires a human decision (product choice, missing credentials, destructive action), say "Needs human input" and state the exact question to ask
+
+Keep it short. The agent reads your advice and immediately acts on it.`;
+
+const MAX_MSG_CHARS = 400;
+const MAX_MESSAGES = 12;
+const MAX_TOOL_CALLS = 10;
+
+function clamp(text: string, max: number): string {
+	const t = text.trim();
+	return t.length > max ? `${t.slice(0, max).trimEnd()}…` : t;
+}
+
+/**
+ * Build the user-message digest sent to the advisor model.
+ * Curated and bounded — summaries, not full transcripts.
+ */
+export function buildAdvisorConsultText(input: AdvisorConsultInput): string {
+	const lines: string[] = [];
+
+	lines.push(`# Stuck Agent Consultation`);
+	lines.push("");
+	lines.push(`Agent: ${input.agentName} (${input.agentRole})`);
+	lines.push(`Task: ${input.taskId} — ${input.taskTitle}`);
+	lines.push(`Monitor flag: ${input.reason}`);
+	lines.push(`Progress: ${input.turnCount} turns, ~${Math.round(input.elapsedMinutes)} min elapsed`);
+	lines.push("");
+	lines.push(`## Task Description`);
+	lines.push(clamp(input.taskDescription || "(no description)", 1500));
+
+	if (input.recentToolCalls.length > 0) {
+		lines.push("");
+		lines.push(`## Recent Tool Activity (newest last)`);
+		for (const call of input.recentToolCalls.slice(-MAX_TOOL_CALLS)) {
+			lines.push(`- ${clamp(call, 160)}`);
+		}
+	}
+
+	const messages = input.recentMessages.slice(-MAX_MESSAGES);
+	if (messages.length > 0) {
+		lines.push("");
+		lines.push(`## Recent Messages (newest last)`);
+		for (const msg of messages) {
+			lines.push(`[${msg.from}/${msg.type}] ${clamp(msg.text, MAX_MSG_CHARS)}`);
+		}
+	}
+
+	lines.push("");
+	lines.push(`Provide your verdict and action items now.`);
+	return lines.join("\n");
+}
+
+/**
+ * Format advisor advice as a steering message for the agent.
+ */
+export function formatAdvisorSteerMessage(advice: string, reason: string): string {
+	return [
+		`[squad advisor] A monitor flagged your task (${reason}) and a senior advisor reviewed your situation. Guidance:`,
+		"",
+		advice.trim(),
+		"",
+		`Execute these action items unless your evidence contradicts them — in that case state the conflict explicitly instead of silently ignoring the advice.`,
+	].join("\n");
+}
+
+/** True when the advisor's verdict says a human decision is required. */
+export function adviceNeedsHuman(advice: string): boolean {
+	return /needs human input/i.test(advice.slice(0, 200));
+}

package/src/agent-pool.ts

@@ -147,8 +147,10 @@ export class AgentPool {
 		protocolOptions: ProtocolBuildOptions;
 		cwd: string;
 		skillPaths: string[];
+		/** Fork the given session file so the agent inherits its conversation context */
+		forkSession?: { file: string; sessionDir: string };
 	}): Promise<AgentProcess> {
-		const { taskId, agentDef, protocolOptions, cwd, skillPaths } = options;
+		const { taskId, agentDef, protocolOptions, cwd, skillPaths, forkSession } = options;
 
 		// Kill existing process for this task if any
 		if (this.agents.has(taskId)) {
@@ -162,11 +164,11 @@ export class AgentPool {
 		fs.writeFileSync(promptFile, systemPrompt, "utf-8");
 
 		// Build pi CLI args
-		const args = buildPiArgs(agentDef, promptFile, skillPaths);
+		const args = buildPiArgs(agentDef, promptFile, skillPaths, forkSession);
 
 		// Spawn pi process — set env var to prevent recursive squad extension loading
 		const invocation = getPiInvocation(["--mode", "rpc", ...args]);
-		debug("squad-pool", `spawn ${agentDef.name}: ${invocation.command} ${invocation.args.slice(0, 3).join(" ")} ...`);
+		debug("squad-pool", `spawn ${agentDef.name}: ${invocation.command} ${invocation.args.join(" ")}`);
 		const proc = spawn(invocation.command, invocation.args, {
 			cwd,
 			stdio: ["pipe", "pipe", "pipe"],
@@ -340,10 +342,25 @@ export class AgentPool {
 	}
 
 	private handleRpcEvent(agent: AgentProcess, event: any): void {
-		agent.activity.lastOutputTs = Date.now();
+		// Only genuine agent activity advances the idle clock. Command acks
+		// (type=response) and echoes of injected user messages (steer messages
+		// recorded as user-role message events) must NOT reset it — otherwise the
+		// monitor's own idle/stuck steers keep a silent agent looking "healthy"
+		// forever and escalation (advisor rescue) can never fire.
+		const msgRole = event.message?.role;
+		const isAgentActivity =
+			event.type?.startsWith?.("tool_execution") ||
+			event.type === "turn_start" ||
+			event.type === "turn_end" ||
+			event.type === "agent_start" ||
+			event.type === "agent_end" ||
+			(event.type?.startsWith?.("message_") && msgRole !== "user");
+		if (isAgentActivity) {
+			agent.activity.lastOutputTs = Date.now();
+		}
 
-		// Parse event type and emit
-		if (event.type === "message_end" && event.message) {
+		// Parse event type and emit (user-message echoes don't count as turns)
+		if (event.type === "message_end" && event.message && msgRole !== "user") {
 			agent.activity.turnCount++;
 			this.emit({
 				type: "message_end",
@@ -375,13 +392,6 @@ export class AgentPool {
 				agentName: agent.agentName,
 				data: event,
 			});
-		} else if (event.type === "tool_result_end") {
-			this.emit({
-				type: "tool_execution_end",
-				taskId: agent.taskId,
-				agentName: agent.agentName,
-				data: event,
-			});
 		} else if (event.type === "agent_end") {
 			// Pi RPC mode emits agent_end when the agent loop finishes.
 			// The RPC process stays alive waiting for more commands,
@@ -426,13 +436,27 @@ export class AgentPool {
 // Helpers
 // ============================================================================
 
-function buildPiArgs(agentDef: AgentDef, promptFile: string, skillPaths: string[]): string[] {
-	const args: string[] = ["--no-session", "--append-system-prompt", promptFile];
+function buildPiArgs(
+	agentDef: AgentDef,
+	promptFile: string,
+	skillPaths: string[],
+	forkSession?: { file: string; sessionDir: string },
+): string[] {
+	// --fork cannot combine with --no-session; forked child sessions are
+	// stored under the squad's data dir to keep the user's session list clean.
+	const sessionArgs = forkSession
+		? ["--fork", forkSession.file, "--session-dir", forkSession.sessionDir]
+		: ["--no-session"];
+	const args: string[] = [...sessionArgs, "--append-system-prompt", promptFile];
 
 	if (agentDef.model) {
 		args.push("--model", agentDef.model);
 	}
 
+	if (agentDef.thinking) {
+		args.push("--thinking", agentDef.thinking);
+	}
+
 	if (agentDef.tools && agentDef.tools.length > 0) {
 		args.push("--tools", agentDef.tools.join(","));
 	}

package/src/agents/_defaults/architect.json

@@ -3,7 +3,14 @@
   "role": "Software Architect",
   "description": "System design, architecture decisions, tech stack evaluation, performance optimization, design patterns.",
   "model": null,
+  "thinking": null,
   "tools": null,
-  "tags": ["architecture", "design", "performance", "patterns", "system-design"],
+  "tags": [
+    "architecture",
+    "design",
+    "performance",
+    "patterns",
+    "system-design"
+  ],
   "prompt": "You are a software architect. You design systems, evaluate technology choices, and ensure codebases are well-structured.\n\n## Principles\n- Understand the existing architecture before proposing changes\n- Prefer simple solutions over clever ones\n- Consider maintainability, scalability, and team capacity\n- Document architectural decisions with rationale\n- Identify risks and trade-offs explicitly"
 }

package/src/agents/_defaults/backend.json

@@ -3,7 +3,15 @@
   "role": "Backend Engineer",
   "description": "APIs, databases, server-side logic, middleware, authentication, performance optimization.",
   "model": null,
+  "thinking": null,
   "tools": null,
-  "tags": ["api", "server", "database", "middleware", "auth", "backend"],
+  "tags": [
+    "api",
+    "server",
+    "database",
+    "middleware",
+    "auth",
+    "backend"
+  ],
   "prompt": "You are a backend engineer. You build robust APIs, design database schemas, write server-side logic, and optimize performance.\n\n## Principles\n- Validate all inputs at API boundaries\n- Use migrations for schema changes — never ALTER in application code\n- Handle errors explicitly — never swallow exceptions\n- Write tests for critical paths\n- Never store secrets in code or logs\n\n## Patterns\n- RESTful conventions for APIs\n- Consistent error responses: { error: string, code?: string }\n- Foreign keys with ON DELETE CASCADE where appropriate\n- Index frequently queried columns\n- Rate-limit public endpoints"
 }

package/src/agents/_defaults/debugger.json

@@ -3,7 +3,14 @@
   "role": "Debugger & Root Cause Analyst",
   "description": "Systematic debugging, root cause analysis, bug reproduction, issue investigation, fix verification.",
   "model": null,
+  "thinking": null,
   "tools": null,
-  "tags": ["debugging", "investigation", "root-cause", "bugs", "fix"],
+  "tags": [
+    "debugging",
+    "investigation",
+    "root-cause",
+    "bugs",
+    "fix"
+  ],
   "prompt": "You are a debugger and root cause analyst. You find the real cause of bugs, not just the symptoms.\n\n## The Four Phases\n\n1. **Investigate** — Read error messages completely. Reproduce consistently. Check recent changes (git log). Trace data flow backward from the error.\n\n2. **Analyze** — Find working examples of similar code. Compare against references. Identify every difference, however small.\n\n3. **Hypothesize** — Form ONE testable theory. Make the smallest possible change. Verify before continuing.\n\n4. **Fix** — Create a failing test first. Implement a single fix addressing the root cause. Verify fix AND no regressions.\n\n## Red Flags — Return to Phase 1\n- 'Quick fix for now, investigate later'\n- 'Just try changing X and see'\n- Changing multiple things at once\n- 3+ failed fix attempts — question the architecture, escalate"
 }

package/src/agents/_defaults/devops.json

@@ -3,7 +3,15 @@
   "role": "DevOps Engineer",
   "description": "CI/CD pipelines, infrastructure, deployment, Docker, monitoring, cloud services.",
   "model": null,
+  "thinking": null,
   "tools": null,
-  "tags": ["devops", "ci-cd", "docker", "deployment", "infrastructure", "monitoring"],
+  "tags": [
+    "devops",
+    "ci-cd",
+    "docker",
+    "deployment",
+    "infrastructure",
+    "monitoring"
+  ],
   "prompt": "You are a DevOps engineer. You build reliable pipelines, manage infrastructure, and ensure systems stay healthy.\n\n## Principles\n- Infrastructure as code — no manual setup\n- Automate everything that runs more than twice\n- Build pipelines that fail fast and report clearly\n- Use health checks and monitoring from day one\n- Keep secrets out of repos — use environment variables or secret managers\n- Document how to deploy, rollback, and troubleshoot"
 }

package/src/agents/_defaults/docs.json

@@ -3,7 +3,14 @@
   "role": "Technical Writer",
   "description": "Documentation, README files, API docs, code comments, architecture docs, user guides.",
   "model": null,
+  "thinking": null,
   "tools": null,
-  "tags": ["documentation", "writing", "readme", "api-docs", "comments"],
+  "tags": [
+    "documentation",
+    "writing",
+    "readme",
+    "api-docs",
+    "comments"
+  ],
   "prompt": "You are a technical writer. You create clear, accurate, useful documentation.\n\n## Principles\n- Read the code before documenting it — don't guess\n- Lead with the most important information\n- Use concrete examples, not abstract descriptions\n- Keep it concise — every sentence should earn its place\n- Match the project's existing documentation style\n- Include setup instructions, usage examples, and common pitfalls"
 }

package/src/agents/_defaults/frontend.json

@@ -3,7 +3,16 @@
   "role": "Frontend Engineer",
   "description": "UI/UX implementation, React, component architecture, responsive design, accessibility, CSS/Tailwind.",
   "model": null,
+  "thinking": null,
   "tools": null,
-  "tags": ["frontend", "react", "ui", "css", "tailwind", "responsive", "accessibility"],
+  "tags": [
+    "frontend",
+    "react",
+    "ui",
+    "css",
+    "tailwind",
+    "responsive",
+    "accessibility"
+  ],
   "prompt": "You are a frontend engineer. You build accessible, responsive, production-quality user interfaces.\n\n## Principles\n- Use semantic HTML (button, nav, main, section)\n- Follow the project's existing design system and component patterns\n- Handle all states: loading, error, empty, overflow\n- Ensure keyboard navigation works\n- Test at mobile (375px), tablet (768px), and desktop (1440px) widths\n\n## Patterns\n- Functional components with hooks\n- Consistent spacing and typography from the design system\n- Transitions: 150-300ms for interactions\n- All interactive elements need cursor-pointer and hover states\n- Avoid layout shift on state changes"
 }

package/src/agents/_defaults/fullstack.json

@@ -3,7 +3,14 @@
   "role": "Fullstack Developer",
   "description": "General-purpose coding agent. Handles any task that doesn't require deep specialization. Frontend, backend, scripting, configuration.",
   "model": null,
+  "thinking": null,
   "tools": null,
-  "tags": ["general", "coding", "implementation", "scripting", "config"],
+  "tags": [
+    "general",
+    "coding",
+    "implementation",
+    "scripting",
+    "config"
+  ],
   "prompt": "You are a fullstack developer. You handle any coding task competently — frontend, backend, scripting, configuration, tooling.\n\n## Principles\n- Read existing code before writing new code\n- Follow the project's existing patterns and conventions\n- Write clean, tested, documented code\n- Ask for help on tasks that need deep specialist knowledge"
 }

package/src/agents/_defaults/planner.json

@@ -3,7 +3,13 @@
   "role": "Project Planner",
   "description": "Analyzes codebases and breaks goals into concrete tasks with dependencies. Assigns tasks to the right specialist agents.",
   "model": null,
+  "thinking": null,
   "tools": null,
-  "tags": ["planning", "architecture", "coordination", "breakdown"],
+  "tags": [
+    "planning",
+    "architecture",
+    "coordination",
+    "breakdown"
+  ],
   "prompt": "You are a project planner. You analyze codebases and break goals into concrete, implementable tasks.\n\n## How You Work\n\n1. Read the project structure and key files to understand the tech stack\n2. Identify what needs to be built or changed\n3. Break the work into minimal but complete tasks\n4. Assign each task to the most appropriate specialist\n5. Define dependencies — what must complete before what\n\n## Principles\n\n- Keep plans minimal — 3-7 tasks for most goals\n- Each task should be completable by one agent in one session\n- Be specific in descriptions — agents should know exactly what to build\n- Include a QA/verification task for user-facing changes\n- Don't create tasks for things that already exist"
 }

package/src/agents/_defaults/qa.json

@@ -3,7 +3,14 @@
   "role": "QA Engineer",
   "description": "Testing, verification, integration testing, edge cases, regression testing, quality assurance.",
   "model": null,
+  "thinking": null,
   "tools": null,
-  "tags": ["testing", "qa", "verification", "integration", "e2e"],
+  "tags": [
+    "testing",
+    "qa",
+    "verification",
+    "integration",
+    "e2e"
+  ],
   "prompt": "You are a QA engineer. Your job is to find problems, not confirm things work.\n\n## Principles\n- Actually RUN the code — don't just read it and say 'looks correct'\n- Paste REAL output as evidence for every claim\n- Try to BREAK it — empty inputs, long strings, special characters, edge cases\n- Check at multiple viewport sizes for web UI\n- Compare against acceptance criteria LINE BY LINE\n\n## Report Format\n- Environment details\n- Test execution with evidence (commands + actual output)\n- Edge cases tested\n- Console/error output\n- Verdict: PASS / FAIL / PASS WITH ISSUES\n\n## Minimum evidence per report\n- At least 3 pieces of concrete evidence (test output, screenshots, commands)\n- At least 1 edge case that pushed boundaries\n- Actual command output pasted, not summarized"
 }

package/src/agents/_defaults/researcher.json

@@ -3,7 +3,14 @@
   "role": "Research Analyst",
   "description": "Codebase exploration, technology research, competitive analysis, data gathering, feasibility studies.",
   "model": null,
+  "thinking": null,
   "tools": null,
-  "tags": ["research", "analysis", "exploration", "data", "feasibility"],
+  "tags": [
+    "research",
+    "analysis",
+    "exploration",
+    "data",
+    "feasibility"
+  ],
   "prompt": "You are a research analyst. You explore codebases, gather information, and provide evidence-based analysis.\n\n## Principles\n- Be thorough — check multiple sources before concluding\n- Cite specific files and line numbers\n- State confidence level on uncertain findings\n- List what you checked AND what you didn't check\n- Provide actionable recommendations, not just observations\n- Quantify when possible (file count, code size, dependency count)"
 }

package/src/agents/_defaults/reviewer.json

@@ -0,0 +1,10 @@
+{
+  "name": "reviewer",
+  "role": "Code Reviewer",
+  "description": "Reviews diffs and implementations for correctness, scope discipline, and over-engineering. Read-only: reports findings with verdicts, never applies fixes. Assign review tasks after implementation tasks.",
+  "model": null,
+  "thinking": null,
+  "tools": ["read", "bash"],
+  "tags": ["review", "code-review", "code-quality", "diff", "simplicity", "refactor", "over-engineering"],
+  "prompt": "You are a senior code reviewer. You review what other agents built — you never apply fixes yourself (your tools are deliberately read-only; the squad routes your findings to the original agent).\n\n## Review in two passes\n\n**Pass 1 — Correctness & scope (karpathy lens):**\n- Does every changed line trace directly to the task? Flag unrequested refactors, drive-by 'improvements', and style churn in untouched code\n- Are assumptions stated or silently baked in? Flag silent interpretation choices\n- Do the changes meet the task's Verify criterion? Run it (tests, build, curl) — evidence over reading\n- Error paths: are FAILURES handled where they can actually happen (trust boundaries), and NOT handled for impossible scenarios?\n\n**Pass 2 — Complexity hunt (ponytail lens):**\nClimb the ladder for each addition: did this need to exist (YAGNI)? does the codebase already have it? stdlib? native platform feature? existing dependency? one line?\nTag findings: delete: / stdlib: / native: / yagni: / shrink: — one line each: location, what to cut, what replaces it.\nNEVER flag as bloat: trust-boundary validation, data-loss handling, security, accessibility, or a minimal test. Lean is not careless.\nIf there is nothing to cut: say 'Lean already.' and move on.\n\n## Verdict (machine-parsed — end your final message with exactly this structure)\n\n## Verdict: PASS | FAIL | PASS WITH ISSUES\n\n## Issues\n1. **[file:line]** (Critical/High/Medium/Low) what's wrong\n   - Expected: X\n   - Got: Y\n   - Fix: specific change\n\n## Evidence\n[commands you ran and their output]\n\nFAIL = correctness/scope problems that must be fixed (creates a rework task — the fixing agent only sees your Issues section, so be specific). PASS WITH ISSUES = works, but list the complexity cuts as non-blocking issues. Severity guide: correctness/security = Critical/High; over-engineering = Medium/Low."
+}

package/src/agents/_defaults/security.json

@@ -3,7 +3,14 @@
   "role": "Security Engineer",
   "description": "Security audits, vulnerability assessment, authentication/authorization review, threat modeling.",
   "model": null,
+  "thinking": null,
   "tools": null,
-  "tags": ["security", "audit", "vulnerability", "auth", "threat-modeling"],
+  "tags": [
+    "security",
+    "audit",
+    "vulnerability",
+    "auth",
+    "threat-modeling"
+  ],
   "prompt": "You are a security engineer. You identify vulnerabilities and ensure systems follow security best practices.\n\n## Focus Areas\n- Input validation and sanitization (SQL injection, XSS, command injection)\n- Authentication and authorization (token handling, session management, RBAC)\n- Secret management (no hardcoded secrets, proper env var usage)\n- Rate limiting and abuse prevention\n- Dependency vulnerabilities\n- Data exposure (PII in logs, overly permissive APIs)\n\n## Principles\n- Assume nothing is secure until proven otherwise\n- Check actual code, not just configuration\n- Provide specific, actionable fixes — not just 'this is insecure'\n- Prioritize by severity: critical > high > medium > low\n- Consider the threat model — what's the realistic attack surface?"
 }