supipowers 0.2.7 → 0.4.0

package/src/commands/fix-pr.ts

@@ -0,0 +1,324 @@
+import type { ExtensionAPI } from "@oh-my-pi/pi-coding-agent";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { loadFixPrConfig, saveFixPrConfig, DEFAULT_FIX_PR_CONFIG } from "../fix-pr/config.js";
+import { buildFixPrOrchestratorPrompt } from "../fix-pr/prompt-builder.js";
+import type { FixPrConfig, ReviewerType, CommentReplyPolicy } from "../fix-pr/types.js";
+import {
+  generateFixPrSessionId,
+  createFixPrSession,
+  findActiveFixPrSession,
+  getSessionDir,
+} from "../storage/fix-pr-sessions.js";
+import { notifyInfo, notifyError, notifyWarning } from "../notifications/renderer.js";
+
+function getScriptsDir(): string {
+  return path.join(path.dirname(new URL(import.meta.url).pathname), "..", "fix-pr", "scripts");
+}
+
+function findSkillPath(skillName: string): string | null {
+  const candidates = [
+    path.join(process.cwd(), "skills", skillName, "SKILL.md"),
+    path.join(path.dirname(new URL(import.meta.url).pathname), "..", "..", "skills", skillName, "SKILL.md"),
+  ];
+  for (const p of candidates) {
+    if (fs.existsSync(p)) return p;
+  }
+  return null;
+}
+
+export function registerFixPrCommand(pi: ExtensionAPI): void {
+  pi.registerCommand("supi:fix-pr", {
+    description: "Fix PR review comments with token-optimized agent orchestration",
+    async handler(args, ctx) {
+      // ── Step 1: Detect PR ──────────────────────────────────────────
+      let prNumber: number | null = null;
+      let repo: string | null = null;
+
+      // Try to parse from args
+      const argTrimmed = args?.trim().replace("#", "") || "";
+      if (/^\d+$/.test(argTrimmed)) {
+        prNumber = parseInt(argTrimmed, 10);
+      }
+
+      // Detect repo
+      try {
+        const repoResult = await pi.exec("gh", ["repo", "view", "--json", "nameWithOwner", "-q", ".nameWithOwner"], { cwd: ctx.cwd });
+        if (repoResult.code === 0) repo = repoResult.stdout.trim();
+      } catch { /* ignore */ }
+
+      if (!repo) {
+        notifyError(ctx, "Could not detect repository", "Run from a git repo with gh CLI configured");
+        return;
+      }
+
+      // Detect PR number from current branch if not provided
+      if (!prNumber) {
+        try {
+          const prResult = await pi.exec("gh", ["pr", "view", "--json", "number", "-q", ".number"], { cwd: ctx.cwd });
+          if (prResult.code === 0) prNumber = parseInt(prResult.stdout.trim(), 10);
+        } catch { /* ignore */ }
+      }
+
+      if (!prNumber) {
+        notifyError(ctx, "No PR found", "Provide PR number as argument or run from a PR branch");
+        return;
+      }
+
+      // ── Step 2: Load or create config ──────────────────────────────
+      let config = loadFixPrConfig(ctx.cwd);
+
+      if (!config && ctx.hasUI) {
+        config = await runSetupWizard(ctx);
+        if (!config) return; // user cancelled
+        saveFixPrConfig(ctx.cwd, config);
+        ctx.ui.notify("Fix-PR config saved to .omp/supipowers/fix-pr.json", "info");
+      }
+
+      if (!config) {
+        notifyError(ctx, "No fix-pr config", "Run interactively first to set up configuration");
+        return;
+      }
+
+      // ── Step 3: Session handling ───────────────────────────────────
+      let activeSession = findActiveFixPrSession(ctx.cwd);
+
+      if (activeSession && ctx.hasUI) {
+        const choice = await ctx.ui.select(
+          "Fix-PR Session",
+          [
+            `Resume ${activeSession.id} (iteration ${activeSession.iteration}, PR #${activeSession.prNumber})`,
+            "Start new session",
+          ],
+          { helpText: "Select session · Esc to cancel" },
+        );
+        if (!choice) return;
+        if (choice.startsWith("Start new")) activeSession = null;
+      }
+
+      const ledger = activeSession ?? {
+        id: generateFixPrSessionId(),
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        prNumber,
+        repo,
+        status: "running" as const,
+        iteration: 0,
+        config,
+        commentsProcessed: [],
+      };
+
+      if (!activeSession) {
+        createFixPrSession(ctx.cwd, ledger);
+      }
+
+      // ── Step 4: Fetch initial comments ─────────────────────────────
+      const sessionDir = getSessionDir(ctx.cwd, ledger.id);
+      const scriptsDir = getScriptsDir();
+      const snapshotPath = path.join(sessionDir, "snapshots", `comments-${ledger.iteration}.jsonl`);
+
+      const fetchResult = await pi.exec("bash", [
+        path.join(scriptsDir, "fetch-pr-comments.sh"),
+        repo,
+        String(prNumber),
+        snapshotPath,
+      ], { cwd: ctx.cwd });
+
+      if (fetchResult.code !== 0) {
+        notifyError(ctx, "Failed to fetch PR comments", fetchResult.stderr);
+        return;
+      }
+
+      // Read the snapshot
+      let comments = "";
+      try {
+        comments = fs.readFileSync(snapshotPath, "utf-8").trim();
+      } catch {
+        notifyWarning(ctx, "No comments found", "PR has no review comments to process");
+        return;
+      }
+
+      if (!comments) {
+        notifyInfo(ctx, "No comments to process", "PR has no review comments");
+        return;
+      }
+
+      const commentCount = comments.split("\n").length;
+
+      // ── Step 5: Load skill ─────────────────────────────────────────
+      let skillContent = "";
+      const skillPath = findSkillPath("fix-pr");
+      if (skillPath) {
+        try {
+          skillContent = fs.readFileSync(skillPath, "utf-8");
+        } catch { /* proceed without */ }
+      }
+
+      // ── Step 6: Build and send prompt ──────────────────────────────
+      const prompt = buildFixPrOrchestratorPrompt({
+        prNumber,
+        repo,
+        comments,
+        sessionDir,
+        scriptsDir,
+        config,
+        iteration: ledger.iteration,
+        skillContent,
+      });
+
+      pi.sendMessage(
+        {
+          customType: "supi-fix-pr",
+          content: [{ type: "text", text: prompt }],
+          display: "none",
+        },
+        { deliverAs: "steer" },
+      );
+
+      notifyInfo(ctx, `Fix-PR started: PR #${prNumber}`, `${commentCount} comments to assess | session ${ledger.id}`);
+    },
+  });
+}
+
+// ── Setup Wizard ───────────────────────────────────────────────────────
+
+const REVIEWER_OPTIONS = [
+  "CodeRabbit",
+  "GitHub Copilot",
+  "Gemini Code Review",
+  "None",
+];
+
+const REVIEWER_DEFAULTS: Record<string, string> = {
+  "CodeRabbit": "/review",
+  "GitHub Copilot": "@copilot review",
+  "Gemini Code Review": "/gemini review",
+};
+
+const POLICY_OPTIONS = [
+  "Answer all comments",
+  "Only answer wrong/unnecessary ones (recommended)",
+  "Don't answer, just fix",
+];
+
+const DELAY_OPTIONS = [
+  "60 seconds",
+  "120 seconds",
+  "180 seconds (recommended)",
+  "300 seconds",
+];
+
+const ITERATION_OPTIONS = [
+  "1",
+  "2",
+  "3 (recommended)",
+  "5",
+];
+
+const MODEL_TIER_OPTIONS = [
+  "high — thorough reasoning, more tokens",
+  "low — fast execution, fewer tokens",
+];
+
+async function runSetupWizard(ctx: any): Promise<FixPrConfig | null> {
+  // 1. Automated reviewer
+  const reviewerChoice = await ctx.ui.select(
+    "Automated PR reviewer",
+    REVIEWER_OPTIONS,
+    { helpText: "Select your automated reviewer, if any" },
+  );
+  if (!reviewerChoice) return null;
+
+  let reviewerType: ReviewerType = "none";
+  let triggerMethod: string | null = null;
+
+  if (reviewerChoice !== "None") {
+    reviewerType = reviewerChoice.toLowerCase().replace(/ /g, "").replace("github", "") as ReviewerType;
+    // Normalize to our type names
+    if (reviewerChoice === "CodeRabbit") reviewerType = "coderabbit";
+    else if (reviewerChoice === "GitHub Copilot") reviewerType = "copilot";
+    else if (reviewerChoice === "Gemini Code Review") reviewerType = "gemini";
+
+    const defaultTrigger = REVIEWER_DEFAULTS[reviewerChoice] || "";
+    triggerMethod = await ctx.ui.input(
+      "How to trigger re-review?",
+      defaultTrigger,
+      { helpText: `Default for ${reviewerChoice}: ${defaultTrigger}` },
+    );
+    if (triggerMethod === undefined) return null;
+    if (!triggerMethod) triggerMethod = defaultTrigger;
+  }
+
+  // 2. Comment reply policy
+  const policyChoice = await ctx.ui.select(
+    "Comment reply policy",
+    POLICY_OPTIONS,
+    { helpText: "How should we handle replying to comments?" },
+  );
+  if (!policyChoice) return null;
+
+  let commentPolicy: CommentReplyPolicy = "answer-selective";
+  if (policyChoice.startsWith("Answer all")) commentPolicy = "answer-all";
+  else if (policyChoice.startsWith("Don't")) commentPolicy = "no-answer";
+
+  // 3. Loop timing
+  const delayChoice = await ctx.ui.select(
+    "Delay between review checks",
+    DELAY_OPTIONS,
+    { helpText: "How long to wait for reviewer after pushing changes" },
+  );
+  if (!delayChoice) return null;
+  const delaySeconds = parseInt(delayChoice, 10);
+
+  const iterChoice = await ctx.ui.select(
+    "Max review iterations",
+    ITERATION_OPTIONS,
+    { helpText: "Maximum fix-check-fix cycles" },
+  );
+  if (!iterChoice) return null;
+  const maxIterations = parseInt(iterChoice, 10);
+
+  // 4. Model preferences
+  const orchestratorTier = await ctx.ui.select(
+    "Orchestrator model tier (assessment & grouping)",
+    MODEL_TIER_OPTIONS,
+    { helpText: "Higher tier = more thorough analysis" },
+  );
+  if (!orchestratorTier) return null;
+
+  const plannerTier = await ctx.ui.select(
+    "Planner model tier (fix planning)",
+    MODEL_TIER_OPTIONS,
+    { helpText: "Higher tier = more detailed plans" },
+  );
+  if (!plannerTier) return null;
+
+  const fixerTier = await ctx.ui.select(
+    "Fixer model tier (code changes)",
+    MODEL_TIER_OPTIONS,
+    { helpText: "Lower tier usually sufficient for execution" },
+  );
+  if (!fixerTier) return null;
+
+  const config: FixPrConfig = {
+    reviewer: { type: reviewerType, triggerMethod },
+    commentPolicy,
+    loop: { delaySeconds, maxIterations },
+    models: {
+      orchestrator: {
+        ...DEFAULT_FIX_PR_CONFIG.models.orchestrator,
+        tier: orchestratorTier.startsWith("high") ? "high" : "low",
+      },
+      planner: {
+        ...DEFAULT_FIX_PR_CONFIG.models.planner,
+        tier: plannerTier.startsWith("high") ? "high" : "low",
+      },
+      fixer: {
+        ...DEFAULT_FIX_PR_CONFIG.models.fixer,
+        tier: fixerTier.startsWith("high") ? "high" : "low",
+      },
+    },
+  };
+
+  return config;
+}

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" }