supipowers 0.2.6 → 0.3.0

package/src/commands/plan.ts

@@ -1,10 +1,29 @@
 import type { ExtensionAPI } from "@oh-my-pi/pi-coding-agent";
 import { loadConfig } from "../config/loader.js";
 import { savePlan } from "../storage/plans.js";
-import { notifySuccess, notifyInfo } from "../notifications/renderer.js";
+import { notifySuccess, notifyInfo, notifyError } from "../notifications/renderer.js";
+import {
+  generateVisualSessionId,
+  createSessionDir,
+  getScriptsDir,
+  parseServerInfo,
+} from "../visual/companion.js";
+import { buildVisualInstructions } from "../visual/prompt-instructions.js";
+import { buildPlanningPrompt, buildQuickPlanPrompt } from "../planning/prompt-builder.js";
 import * as fs from "node:fs";
 import * as path from "node:path";
 
+/** Module-level tracking for cleanup */
+let activeSessionDir: string | null = null;
+
+export function getActiveVisualSessionDir(): string | null {
+  return activeSessionDir;
+}
+
+export function setActiveVisualSessionDir(dir: string | null): void {
+  activeSessionDir = dir;
+}
+
 export function registerPlanCommand(pi: ExtensionAPI): void {
   pi.registerCommand("supi:plan", {
     description: "Start collaborative planning for a feature or task",
@@ -24,39 +43,85 @@ export function registerPlanCommand(pi: ExtensionAPI): void {
       const isQuick = args?.startsWith("--quick");
       const quickDesc = isQuick ? args.replace("--quick", "").trim() : "";
 
+      // ── Visual companion consent ──────────────────────────────────
+      let visualUrl: string | null = null;
+      let visualSessionDir: string | null = null;
+
+      if (ctx.hasUI && !isQuick) {
+        const modeChoice = await ctx.ui.select(
+          "Planning mode",
+          [
+            "Terminal only",
+            "Terminal + Visual companion (opens browser)",
+          ],
+          { helpText: "Visual companion shows mockups and diagrams in a browser · Esc to cancel" },
+        );
+        if (!modeChoice) return;
+
+        if (modeChoice.startsWith("Terminal + Visual")) {
+          const sessionId = generateVisualSessionId();
+          visualSessionDir = createSessionDir(ctx.cwd, sessionId);
+          const scriptsDir = getScriptsDir();
+
+          // Install server dependencies if needed
+          const nodeModules = path.join(scriptsDir, "node_modules");
+          if (!fs.existsSync(nodeModules)) {
+            notifyInfo(ctx, "Installing visual companion dependencies...");
+            const installResult = await pi.exec("npm", ["install", "--production"], { cwd: scriptsDir });
+            if (installResult.code !== 0) {
+              notifyError(ctx, "Failed to install visual companion dependencies", installResult.stderr);
+              visualSessionDir = null;
+            }
+          }
+
+          if (visualSessionDir) {
+            // Stop any previous visual companion
+            if (activeSessionDir) {
+              const stopScript = path.join(scriptsDir, "stop-server.sh");
+              await pi.exec("bash", [stopScript, activeSessionDir], { cwd: scriptsDir });
+            }
+
+            // Start the server (pass session dir via env command since ExecOptions has no env)
+            const startScript = path.join(scriptsDir, "start-server.sh");
+            const startResult = await pi.exec("env", [
+              `SUPI_VISUAL_DIR=${visualSessionDir}`,
+              "bash",
+              startScript,
+            ], { cwd: scriptsDir });
+
+            if (startResult.code === 0) {
+              const serverInfo = parseServerInfo(startResult.stdout);
+              if (serverInfo) {
+                visualUrl = serverInfo.url;
+                activeSessionDir = visualSessionDir;
+                notifyInfo(ctx, "Visual companion ready", visualUrl);
+              } else {
+                notifyError(ctx, "Visual companion started but no connection info received");
+                visualSessionDir = null;
+              }
+            } else {
+              const errorMsg = startResult.stderr || startResult.stdout;
+              notifyError(ctx, "Failed to start visual companion", errorMsg);
+              visualSessionDir = null;
+            }
+          }
+        }
+      }
+
+      // ── Build prompt ──────────────────────────────────────────────
       let prompt: string;
       if (isQuick && quickDesc) {
-        prompt = [
-          "Generate a concise implementation plan for the following task.",
-          "Skip brainstorming — go straight to task breakdown.",
-          "",
-          `Task: ${quickDesc}`,
-          "",
-          "Format the plan as markdown with YAML frontmatter (name, created, tags).",
-          "Each task should have: name, [parallel-safe] or [sequential] annotation,",
-          "**files**, **criteria**, and **complexity** (small/medium/large).",
-          "",
-          skillContent ? "Follow these planning guidelines:\n" + skillContent : "",
-          "",
-          "After generating the plan, save it and confirm with the user.",
-        ].join("\n");
+        prompt = buildQuickPlanPrompt(quickDesc, skillContent || undefined);
       } else {
-        prompt = [
-          "You are starting a collaborative planning session with the user.",
-          "",
-          args ? `The user wants to plan: ${args}` : "Ask the user what they want to build or accomplish.",
-          "",
-          "Process:",
-          "1. Understand the goal — ask clarifying questions (one at a time)",
-          "2. Propose 2-3 approaches with trade-offs",
-          "3. Generate a task breakdown once aligned",
-          "",
-          "Format the final plan as markdown with YAML frontmatter (name, created, tags).",
-          "Each task: name, [parallel-safe] or [sequential] annotation,",
-          "**files**, **criteria**, **complexity** (small/medium/large).",
-          "",
-          skillContent ? "Follow these planning guidelines:\n" + skillContent : "",
-        ].join("\n");
+        prompt = buildPlanningPrompt({
+          topic: args || undefined,
+          skillContent: skillContent || undefined,
+        });
+      }
+
+      // Append visual companion instructions if active
+      if (visualUrl && visualSessionDir) {
+        prompt += "\n\n" + buildVisualInstructions(visualUrl, visualSessionDir);
       }
 
       pi.sendMessage(

package/src/commands/qa.ts

@@ -1,11 +1,30 @@
 import type { ExtensionAPI } from "@oh-my-pi/pi-coding-agent";
 import { detectAndCache } from "../qa/detector.js";
-import { buildQaRunPrompt } from "../qa/runner.js";
 import { notifyInfo, notifyError } from "../notifications/renderer.js";
+import { findActiveSession, findSessionWithFailures } from "../storage/qa-sessions.js";
+import {
+  createNewSession,
+  advancePhase,
+  getFailedTests,
+  getNextPhase,
+  getPhaseStatusLine,
+} from "../qa/session.js";
+import { buildDiscoveryPrompt } from "../qa/phases/discovery.js";
+import { buildMatrixPrompt } from "../qa/phases/matrix.js";
+import { buildExecutionPrompt } from "../qa/phases/execution.js";
+import { buildReportingPrompt } from "../qa/phases/reporting.js";
+import type { QaPhase, QaSessionLedger } from "../types.js";
+
+const PHASE_LABELS: Record<QaPhase, string> = {
+  discovery: "Discovery — Scan for test cases",
+  matrix: "Matrix — Build traceability matrix",
+  execution: "Execution — Run tests",
+  reporting: "Reporting — Generate summary",
+};
 
 export function registerQaCommand(pi: ExtensionAPI): void {
   pi.registerCommand("supi:qa", {
-    description: "Run QA pipeline (test suite, E2E)",
+    description: "Run QA pipeline with session management (discovery → matrix → execution → reporting)",
     async handler(args, ctx) {
       const framework = detectAndCache(ctx.cwd);
 
@@ -13,48 +32,150 @@ export function registerQaCommand(pi: ExtensionAPI): void {
         notifyError(
           ctx,
           "No test framework detected",
-          "Configure manually: /supi:config set qa.framework vitest && /supi:config set qa.command 'npx vitest run'"
+          "Configure manually via /supi:config"
         );
         return;
       }
 
-      let scope: "all" | "changed" | "e2e" = "all";
-      let changedFiles: string[] | undefined;
-
-      if (args?.includes("--changed")) {
-        scope = "changed";
-      } else if (args?.includes("--e2e")) {
-        scope = "e2e";
-      } else if (ctx.hasUI && !args?.trim()) {
-        // No flag provided — let the user pick
-        const choice = await ctx.ui.select(
-          "QA scope",
-          ["all — Run all tests", "changed — Only changed files", "e2e — E2E / Playwright only"],
-          { helpText: "Select test scope · Esc to cancel" },
-        );
-        if (!choice) return;
-        scope = choice.split(" — ")[0] as "all" | "changed" | "e2e";
+      // ── Step 1: Session selection ──────────────────────────────────
+      let ledger: QaSessionLedger | null = null;
+
+      const activeSession = findActiveSession(ctx.cwd);
+      const failedSession = findSessionWithFailures(ctx.cwd);
+
+      if (ctx.hasUI && !args?.trim()) {
+        const sessionOptions: string[] = [];
+
+        if (failedSession) {
+          const failCount = failedSession.results.filter((r) => r.status === "fail").length;
+          sessionOptions.push(`Resume ${failedSession.id} (${failCount} failed test${failCount !== 1 ? "s" : ""})`);
+        } else if (activeSession) {
+          const next = getNextPhase(activeSession);
+          sessionOptions.push(`Resume ${activeSession.id} (${next ?? "all phases done"} pending)`);
+        }
+
+        sessionOptions.push("Start new session");
+
+        if (sessionOptions.length > 1) {
+          const choice = await ctx.ui.select(
+            "QA Session",
+            sessionOptions,
+            { helpText: "Select session · Esc to cancel" },
+          );
+          if (!choice) return;
+
+          if (choice.startsWith("Resume")) {
+            ledger = failedSession ?? activeSession;
+          }
+        }
       }
 
-      if (scope === "changed") {
-        try {
-          const result = await pi.exec("git", ["diff", "--name-only", "HEAD"], { cwd: ctx.cwd });
-          if (result.exitCode === 0) {
-            changedFiles = result.stdout.split("\n").filter((f) => f.trim().length > 0);
+      // Create new session if none selected
+      if (!ledger) {
+        ledger = createNewSession(ctx.cwd, framework.name);
+        notifyInfo(ctx, "QA session created", ledger.id);
+      }
+
+      // ── Step 2: Phase selection ────────────────────────────────────
+      type PhaseAction =
+        | { type: "run-phase"; phase: QaPhase }
+        | { type: "rerun-failed" };
+
+      let action: PhaseAction | null = null;
+      const nextPhase = getNextPhase(ledger);
+      const failedTests = getFailedTests(ledger);
+
+      if (ctx.hasUI && !args?.trim()) {
+        const phaseOptions: string[] = [];
+
+        // Offer re-run failed if there are failures
+        if (failedTests.length > 0) {
+          phaseOptions.push(`Re-run ${failedTests.length} failed test${failedTests.length !== 1 ? "s" : ""} only`);
+        }
+
+        // Offer starting from next pending phase
+        if (nextPhase) {
+          phaseOptions.push(PHASE_LABELS[nextPhase]);
+        }
+
+        if (phaseOptions.length > 1) {
+          const statusLine = getPhaseStatusLine(ledger);
+          const choice = await ctx.ui.select(
+            `QA Phase · ${statusLine}`,
+            phaseOptions,
+            { helpText: "Select action · Esc to cancel" },
+          );
+          if (!choice) return;
+
+          if (choice.startsWith("Re-run")) {
+            action = { type: "rerun-failed" };
+          } else {
+            // Extract phase from label
+            const selectedPhase = (Object.entries(PHASE_LABELS) as [QaPhase, string][])
+              .find(([, label]) => label === choice)?.[0];
+            if (selectedPhase) {
+              action = { type: "run-phase", phase: selectedPhase };
+            }
           }
-        } catch {
-          scope = "all";
+        } else if (nextPhase) {
+          // Only one option — just run the next phase
+          action = { type: "run-phase", phase: nextPhase };
         }
+      } else if (nextPhase) {
+        action = { type: "run-phase", phase: nextPhase };
+      }
+
+      if (!action) {
+        notifyInfo(ctx, "QA pipeline complete", getPhaseStatusLine(ledger));
+        return;
       }
 
-      notifyInfo(ctx, "QA started", `${framework.name} | scope: ${scope}`);
+      // ── Step 3: Execute ────────────────────────────────────────────
+      let prompt: string;
+
+      if (action.type === "rerun-failed") {
+        ledger = advancePhase(ctx.cwd, ledger, "execution", "running");
+        prompt = buildExecutionPrompt(ledger, { failedOnly: true, failedTests });
+        notifyInfo(ctx, "QA re-running failed tests", `${failedTests.length} test(s)`);
+      } else {
+        const phase = action.phase;
+        ledger = advancePhase(ctx.cwd, ledger, phase, "running");
+
+        switch (phase) {
+          case "discovery":
+            prompt = buildDiscoveryPrompt(framework, ctx.cwd);
+            break;
+          case "matrix":
+            prompt = buildMatrixPrompt(ledger);
+            break;
+          case "execution":
+            prompt = buildExecutionPrompt(ledger);
+            break;
+          case "reporting":
+            prompt = buildReportingPrompt(ledger);
+            break;
+        }
+
+        notifyInfo(ctx, `QA phase: ${phase}`, `session: ${ledger.id}`);
+      }
 
-      const prompt = buildQaRunPrompt(framework.command, scope, changedFiles);
+      // Include session context for the sub-agent
+      const sessionContext = [
+        `\n\n## QA Session Context`,
+        ``,
+        `Session ID: ${ledger.id}`,
+        `Session ledger path: .omp/supipowers/qa-sessions/${ledger.id}/ledger.json`,
+        ``,
+        `Current ledger state:`,
+        "```json",
+        JSON.stringify(ledger, null, 2),
+        "```",
+      ].join("\n");
 
       pi.sendMessage(
         {
           customType: "supi-qa",
-          content: [{ type: "text", text: prompt }],
+          content: [{ type: "text", text: prompt + sessionContext }],
           display: "none",
         },
         { deliverAs: "steer" }

package/src/commands/release.ts

@@ -12,7 +12,7 @@ export function registerReleaseCommand(pi: ExtensionAPI): void {
       let lastTag: string | null = null;
       try {
         const result = await pi.exec("git", ["describe", "--tags", "--abbrev=0"], { cwd: ctx.cwd });
-        if (result.exitCode === 0) lastTag = result.stdout.trim();
+        if (result.code === 0) lastTag = result.stdout.trim();
       } catch {
         // no tags yet
       }

package/src/commands/review.ts

@@ -49,7 +49,7 @@ export function registerReviewCommand(pi: ExtensionAPI): void {
       let changedFiles: string[] = [];
       try {
         const result = await pi.exec("git", ["diff", "--name-only", "HEAD"], { cwd: ctx.cwd });
-        if (result.exitCode === 0) {
+        if (result.code === 0) {
           changedFiles = result.stdout
             .split("\n")
             .map((f) => f.trim())
@@ -62,7 +62,7 @@ export function registerReviewCommand(pi: ExtensionAPI): void {
       if (changedFiles.length === 0) {
         try {
           const result = await pi.exec("git", ["diff", "--name-only", "--cached"], { cwd: ctx.cwd });
-          if (result.exitCode === 0) {
+          if (result.code === 0) {
             changedFiles = result.stdout
               .split("\n")
               .map((f) => f.trim())

package/src/commands/run.ts

@@ -11,7 +11,7 @@ import {
   loadAllAgentResults,
 } from "../storage/runs.js";
 import { scheduleBatches } from "../orchestrator/batch-scheduler.js";
-import { dispatchAgent, dispatchFixAgent } from "../orchestrator/dispatcher.js";
+import { dispatchAgent, dispatchAgentWithReview, dispatchFixAgent } from "../orchestrator/dispatcher.js";
 import { summarizeBatch, buildRunSummary } from "../orchestrator/result-collector.js";
 import { analyzeConflicts } from "../orchestrator/conflict-resolver.js";
 import { isLspAvailable } from "../lsp/detector.js";
@@ -22,6 +22,8 @@ import {
   notifyError,
   notifySummary,
 } from "../notifications/renderer.js";
+import { buildWorktreePrompt } from "../git/worktree.js";
+import { buildBranchFinishPrompt } from "../git/branch-finish.js";
 import type { RunManifest, AgentResult } from "../types.js";
 
 export function registerRunCommand(pi: ExtensionAPI): void {
@@ -32,6 +34,7 @@ export function registerRunCommand(pi: ExtensionAPI): void {
       const profile = resolveProfile(ctx.cwd, config, args?.replace("--profile ", "") || undefined);
 
       let manifest = findActiveRun(ctx.cwd);
+      let branchName: string | null = null;
 
       if (!manifest) {
         const plans = listPlans(ctx.cwd);
@@ -60,6 +63,36 @@ export function registerRunCommand(pi: ExtensionAPI): void {
         };
         createRun(ctx.cwd, manifest);
         notifyInfo(ctx, `Run started: ${manifest.id}`, `${plan.tasks.length} tasks in ${batches.length} batches`);
+
+        // Offer worktree setup for isolated execution
+        if (ctx.hasUI) {
+          const useWorktree = await ctx.ui.select(
+            "Execution isolation",
+            [
+              "Run in current workspace",
+              "Create isolated worktree (recommended)",
+            ],
+            { helpText: "Worktrees prevent work-in-progress from polluting your workspace" },
+          );
+          if (!useWorktree) return;
+
+          if (useWorktree.startsWith("Create isolated")) {
+            branchName = `supi/${plan.name || manifest.id}`;
+            const worktreeInstructions = buildWorktreePrompt({
+              branchName,
+              cwd: ctx.cwd,
+            });
+            pi.sendMessage(
+              {
+                customType: "supi-worktree-setup",
+                content: [{ type: "text", text: worktreeInstructions }],
+                display: "none",
+              },
+              { deliverAs: "steer" },
+            );
+            notifyInfo(ctx, "Setting up worktree", `Branch: ${branchName}`);
+          }
+        }
       } else {
         notifyInfo(ctx, `Resuming run: ${manifest.id}`);
       }
@@ -89,7 +122,7 @@ export function registerRunCommand(pi: ExtensionAPI): void {
           const task = plan.tasks.find((t) => t.id === taskId);
           if (!task) return Promise.resolve(null);
 
-          return dispatchAgent({
+          return dispatchAgentWithReview({
             pi,
             ctx,
             task,
@@ -170,6 +203,23 @@ export function registerRunCommand(pi: ExtensionAPI): void {
         `(${runSummary.done} clean, ${runSummary.doneWithConcerns} with concerns, ` +
         `${runSummary.blocked} blocked) | ${runSummary.totalFilesChanged} files | ${durationSec}s`
       );
+
+      // Offer branch finish options if we created a worktree branch
+      if (branchName && manifest.status === "completed") {
+        const finishInstructions = buildBranchFinishPrompt({
+          branchName,
+          baseBranch: "main",
+        });
+        pi.sendMessage(
+          {
+            customType: "supi-branch-finish",
+            content: [{ type: "text", text: finishInstructions }],
+            display: "none",
+          },
+          { deliverAs: "steer" },
+        );
+        notifyInfo(ctx, "Run succeeded", "Follow branch finish instructions to integrate your work");
+      }
     },
   });
 }

package/src/commands/update.ts

@@ -24,7 +24,7 @@ export function handleUpdate(pi: ExtensionAPI, ctx: ExtensionContext): void {
 
     // Check latest version on npm
     const checkResult = await pi.exec("npm", ["view", "supipowers", "version"], { cwd: tmpdir() });
-    if (checkResult.exitCode !== 0) {
+    if (checkResult.code !== 0) {
       ctx.ui.notify("Failed to check for updates — npm view failed", "error");
       return;
     }
@@ -46,7 +46,7 @@ export function handleUpdate(pi: ExtensionAPI, ctx: ExtensionContext): void {
         "npm", ["install", "--prefix", tempDir, `supipowers@${latestVersion}`],
         { cwd: tempDir },
       );
-      if (installResult.exitCode !== 0) {
+      if (installResult.code !== 0) {
         ctx.ui.notify("Failed to download latest version", "error");
         return;
       }

package/src/discipline/debugging.ts

@@ -0,0 +1,57 @@
+/**
+ * Systematic debugging instructions for sub-agent prompts.
+ * Matches superpowers' systematic-debugging skill depth.
+ */
+export function buildDebuggingInstructions(): string {
+  return [
+    "## Systematic Debugging",
+    "",
+    "### Iron Law",
+    "",
+    "NO FIXES WITHOUT ROOT CAUSE INVESTIGATION FIRST.",
+    "Symptom fixes are failure. Find root cause before attempting any fix.",
+    "",
+    "### Phase 1: Root Cause Investigation",
+    "",
+    "Complete this phase before proposing fixes:",
+    "",
+    "1. **Read the error message carefully.** Don't skip it; it often contains the solution.",
+    "2. **Reproduce consistently.** Exact steps, every time.",
+    "3. **Check recent changes.** Run `git diff` to see what changed. Check new dependencies, config changes.",
+    "4. **Gather evidence** in multi-component systems: add diagnostic instrumentation at each boundary.",
+    "5. **Trace the data flow** backward through the call stack to find the original trigger.",
+    "",
+    "### Phase 2: Pattern Analysis",
+    "",
+    "1. Find a working example in the codebase that does something similar.",
+    "2. Compare against the reference completely (don't skim).",
+    "3. Identify differences between working and broken.",
+    "4. Understand dependencies and assumptions.",
+    "",
+    "### Phase 3: Hypothesis and Testing",
+    "",
+    "1. Form a single, specific hypothesis (not vague).",
+    "2. Test minimally: smallest possible change, one variable at a time.",
+    "3. Verify before continuing. If wrong → form a NEW hypothesis, not more fixes.",
+    "4. Admit uncertainty. Don't pretend to know.",
+    "",
+    "### Phase 4: Implementation",
+    "",
+    "1. Create a failing test case first (automated or manual).",
+    "2. Implement a single fix that addresses the root cause only.",
+    "3. Verify the fix: test passes, no other tests broken.",
+    "4. **If the fix doesn't work:**",
+    "   - Fewer than 3 attempts → return to Phase 1 with new information",
+    "   - 3 or more attempts → STOP and question the architecture. Discuss with human partner.",
+    "",
+    "### Red Flags — STOP and Follow the Process",
+    "",
+    "- \"Quick fix for now, investigate later\"",
+    "- \"Just try changing X and see if it works\"",
+    "- \"Skip the test, I'll manually verify\"",
+    "- \"It's probably X, let me fix that\"",
+    "- \"I don't fully understand but this might work\"",
+    "- \"One more fix attempt\" (when already tried 2+)",
+    "- Each fix reveals a new problem in a different place",
+  ].join("\n");
+}

package/src/discipline/receiving-review.ts

@@ -0,0 +1,65 @@
+/**
+ * Receiving code review instructions for sub-agent prompts.
+ * Matches superpowers' receiving-code-review skill:
+ * technical rigor and verification, not performative agreement.
+ */
+export function buildReceivingReviewInstructions(): string {
+  return [
+    "## Receiving Code Review Feedback",
+    "",
+    "Code review requires technical evaluation, not emotional performance.",
+    "Verify before implementing. Ask before assuming. Technical correctness over social comfort.",
+    "",
+    "### The Response Pattern",
+    "",
+    "1. **READ:** Complete feedback without reacting.",
+    "2. **UNDERSTAND:** Restate the requirement in your own words, or ask for clarification.",
+    "3. **VERIFY:** Check against codebase reality.",
+    "4. **EVALUATE:** Is this technically sound for THIS codebase?",
+    "5. **RESPOND:** Technical acknowledgment or reasoned pushback.",
+    "6. **IMPLEMENT:** One at a time, test each change.",
+    "",
+    "### Forbidden Responses",
+    "",
+    "Never use performative agreement:",
+    "- \"You're absolutely right!\"",
+    "- \"Great point!\"",
+    "- \"Excellent catch!\"",
+    "",
+    "Instead: restate requirements, ask clarifying questions, take action.",
+    "",
+    "### Handling Unclear Feedback",
+    "",
+    "If any item is unclear, stop and ask for clarification before implementing anything.",
+    "Items may be related — clarify all unclear items before starting work.",
+    "",
+    "### Source-Specific Handling",
+    "",
+    "**From your human partner:** Trusted. Implement after understanding.",
+    "**From external reviewers:** Verify technically. Check for breaking changes.",
+    "Question whether the reviewer understands the full context.",
+    "",
+    "### YAGNI Check",
+    "",
+    "For suggested \"professional features\" — grep the codebase for actual usage.",
+    "If unused, suggest removal instead of implementing.",
+    "",
+    "### Implementation Order",
+    "",
+    "1. Clarify all unclear items first.",
+    "2. Then implement in order: blocking issues → simple fixes → complex fixes.",
+    "3. Test each change before moving to the next.",
+    "",
+    "### When to Push Back",
+    "",
+    "Push back when feedback would introduce bugs, break existing behavior,",
+    "add unnecessary complexity, or contradicts the codebase's established patterns.",
+    "Use technical reasoning, not defensiveness.",
+    "",
+    "### The Bottom Line",
+    "",
+    "External feedback = suggestions to evaluate, not orders to follow.",
+    "Verify before implementing. Question. Then implement.",
+    "No performative agreement. Technical rigor always.",
+  ].join("\n");
+}