supipowers 1.1.0 → 1.2.2

package/src/commands/release.ts

@@ -3,10 +3,16 @@ import type { ReleaseChannel, BumpType } from "../types.js";
 import { loadConfig, updateConfig } from "../config/loader.js";
 import { detectChannels } from "../release/detector.js";
 import { parseConventionalCommits, buildChangelogMarkdown, summarizeChanges } from "../release/changelog.js";
-import { getCurrentVersion, suggestBump, bumpVersion } from "../release/version.js";
-import { executeRelease } from "../release/executor.js";
+import { getCurrentVersion, suggestBump, bumpVersion, isVersionReleased } from "../release/version.js";
+import { executeRelease, type ReleaseProgressFn } from "../release/executor.js";
 import { buildPolishPrompt } from "../release/prompt.js";
 import { notifyInfo, notifySuccess, notifyError } from "../notifications/renderer.js";
+import { analyzeAndCommit } from "../git/commit.js";
+import { getWorkingTreeStatus } from "../git/status.js";
+
+const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+const STATUS_KEY = "supi-release";
+const WIDGET_KEY = "supi-release";
 
 const BUMP_OPTIONS = [
   "patch — bug fixes only",
@@ -14,28 +20,271 @@ const BUMP_OPTIONS = [
   "major — breaking changes",
 ];
 
+/**
+ * Returns true when re-running supi:release should skip the confirmation
+ * dialog and proceed directly to execution.
+ *
+ * This is the resume path: the version in package.json hasn't been tagged yet
+ * AND all channels are already configured — the user staged the release
+ * deliberately when they bumped the version, so no new decisions are needed.
+ * Dry-run is excluded because it is exploratory by intent; the user explicitly
+ * wants to preview and confirm before anything happens.
+ */
+export function isInProgressRelease(opts: {
+  skipBump: boolean;
+  channelsWerePreConfigured: boolean;
+  isDryRun: boolean;
+}): boolean {
+  return opts.skipBump && opts.channelsWerePreConfigured && !opts.isDryRun;
+}
+
+// ── Release progress tracker ────────────────────────────────────
+
+interface ReleaseStep {
+  label: string;
+  status: "pending" | "active" | "done" | "error" | "skipped";
+  detail?: string;
+}
+
+function createReleaseProgress(ctx: any) {
+  const steps: ReleaseStep[] = [
+    { label: "Check working tree", status: "pending" },
+    { label: "Detect channels", status: "pending" },
+    { label: "Analyze commits", status: "pending" },
+    { label: "Select version", status: "pending" },
+    { label: "Build changelog", status: "pending" },
+    { label: "Execute release", status: "pending" },
+    { label: "Publish channels", status: "pending" },
+  ];
+
+  let frame = 0;
+  let statusDetail = "";
+  let timer: ReturnType<typeof setInterval> | null = null;
+
+  function icon(step: ReleaseStep): string {
+    switch (step.status) {
+      case "done":    return "✓";
+      case "active":  return SPINNER_FRAMES[frame % SPINNER_FRAMES.length];
+      case "error":   return "✗";
+      case "skipped": return "–";
+      default:        return "○";
+    }
+  }
+
+  function renderWidget(): string[] {
+    const lines: string[] = ["┌─ supi:release ─────────────────────┐"];
+    for (const step of steps) {
+      const mark = icon(step);
+      const detail = step.detail ? ` (${step.detail})` : "";
+      lines.push(`│ ${mark} ${step.label}${detail}`);
+    }
+    lines.push("└─────────────────────────────────────┘");
+    return lines;
+  }
+
+  function refresh() {
+    frame++;
+    ctx.ui.setWidget?.(WIDGET_KEY, renderWidget());
+    if (statusDetail) {
+      ctx.ui.setStatus?.(STATUS_KEY, `${SPINNER_FRAMES[frame % SPINNER_FRAMES.length]} ${statusDetail}`);
+    }
+  }
+
+  function startTimer() {
+    if (!timer) {
+      timer = setInterval(refresh, 80);
+    }
+  }
+
+  function stopTimer() {
+    if (timer) {
+      clearInterval(timer);
+      timer = null;
+    }
+  }
+
+  return {
+    activate(stepIndex: number, detail?: string) {
+      const step = steps[stepIndex];
+      if (step) {
+        step.status = "active";
+        step.detail = detail;
+      }
+      statusDetail = detail ?? step?.label ?? "";
+      startTimer();
+      refresh();
+    },
+
+    complete(stepIndex: number, detail?: string) {
+      const step = steps[stepIndex];
+      if (step) {
+        step.status = "done";
+        if (detail !== undefined) step.detail = detail;
+      }
+      refresh();
+    },
+
+    fail(stepIndex: number, detail?: string) {
+      const step = steps[stepIndex];
+      if (step) {
+        step.status = "error";
+        if (detail !== undefined) step.detail = detail;
+      }
+      refresh();
+    },
+
+    skip(stepIndex: number, detail?: string) {
+      const step = steps[stepIndex];
+      if (step) {
+        step.status = "skipped";
+        if (detail !== undefined) step.detail = detail;
+      }
+      refresh();
+    },
+
+    /** Build an onProgress callback for executeRelease. */
+    executorProgress(): ReleaseProgressFn {
+      return (step, status, detail) => {
+        // Map executor steps to sub-detail on "Execute release" (index 5)
+        // or "Publish channels" (index 6)
+        const isPublish = step.startsWith("publish-");
+        const idx = isPublish ? 6 : 5;
+        if (status === "active") this.activate(idx, detail);
+        else if (status === "done") {
+          // Don't mark the overall step done from individual sub-steps
+          const s = steps[idx];
+          if (s) { s.detail = detail; }
+          refresh();
+        } else if (status === "error") this.fail(idx, detail);
+      };
+    },
+
+    dispose() {
+      stopTimer();
+      ctx.ui.setStatus?.(STATUS_KEY, undefined);
+      ctx.ui.setWidget?.(WIDGET_KEY, undefined);
+    },
+  };
+}
+
+/**
+ * Register the command for autocomplete and /help listing.
+ * Actual execution goes through handleRelease via the TUI dispatch.
+ */
 export function registerReleaseCommand(platform: Platform): void {
   platform.registerCommand("supi:release", {
     description: "Release automation — version bump, changelog, publish",
-    async handler(args: string | undefined, ctx: any) {
+    async handler() {
+      // No-op: execution is handled by the TUI input interceptor.
+      // This registration exists only for autocomplete and /help.
+    },
+  });
+}
+
+/**
+ * TUI-only handler — called from the input event dispatcher in bootstrap.ts.
+ * Runs the full release flow without triggering the outer LLM session.
+ */
+export function handleRelease(platform: Platform, ctx: any, args?: string): void {
+  if (!ctx.hasUI) {
+    ctx.ui.notify("Release requires interactive mode", "warning");
+    return;
+  }
+
+  const progress = createReleaseProgress(ctx);
+
+  void (async () => {
+    try {
       const isPolish = args?.includes("--polish") ?? false;
       const isDryRun = args?.includes("--dry-run") ?? false;
       const config = loadConfig(platform.paths, ctx.cwd);
 
+      // 0. Check for uncommitted changes
+      progress.activate(0, "Checking working tree");
+      let didStash = false;
+      const treeStatus = await getWorkingTreeStatus(platform.exec.bind(platform), ctx.cwd);
+      if (treeStatus.dirty) {
+        progress.complete(0, `${treeStatus.files.length} files changed`);
+        const filePreview = treeStatus.files.slice(0, 8).join(", ");
+        const extra = treeStatus.files.length > 8 ? ` (+${treeStatus.files.length - 8} more)` : "";
+
+        const action = await ctx.ui.select(
+          `Uncommitted changes detected (${treeStatus.files.length} files)`,
+          [
+            "commit — commit changes with AI-generated message",
+            "stash \u2014 stash changes and continue",
+            "abort \u2014 cancel release",
+          ],
+          { helpText: `Files: ${filePreview}${extra}` },
+        );
+
+        if (!action || action.startsWith("abort")) {
+          progress.dispose();
+          return;
+        }
+
+        if (action.startsWith("commit")) {
+          // commit.ts has its own progress widget; dispose ours temporarily
+          progress.dispose();
+          const commitResult = await analyzeAndCommit(platform, ctx);
+          if (!commitResult) {
+            notifyError(ctx, "Commit failed or cancelled", "Aborting release.");
+            return;
+          }
+          // Verify tree is now clean
+          const afterStatus = await getWorkingTreeStatus(platform.exec.bind(platform), ctx.cwd);
+          if (afterStatus.dirty) {
+            notifyError(ctx, "Still uncommitted changes", "Not all changes were committed. Aborting release.");
+            return;
+          }
+          // Re-create progress after commit's widget has disposed
+          // (reactivate shows state from where we left off)
+          progress.complete(0, "Committed");
+        } else if (action.startsWith("stash")) {
+          progress.activate(0, "Stashing changes");
+          const stashResult = await platform.exec("git", ["stash", "push", "-m", "supi:release auto-stash"], { cwd: ctx.cwd });
+          if (stashResult.code !== 0) {
+            progress.fail(0, stashResult.stderr || "stash failed");
+            progress.dispose();
+            notifyError(ctx, "git stash failed", stashResult.stderr || "Non-zero exit");
+            return;
+          }
+          didStash = true;
+          progress.complete(0, "Stashed");
+        }
+      } else {
+        progress.complete(0, "Clean");
+      }
+
       // 1. Ensure channels are configured (or detect + ask)
+      progress.activate(1, "Detecting channels");
       let channels = config.release.channels;
+      // Track whether channels were already set in config before any interactive
+      // setup. This distinguishes "user already decided" from "just configured now",
+      // which determines whether we can auto-continue without a confirmation prompt.
+      const channelsWerePreConfigured = config.release.channels.length > 0;
+
       if (channels.length === 0) {
+        progress.complete(1, "Awaiting selection");
         channels = await setupChannels(platform, ctx);
-        if (channels.length === 0) return;
+        if (channels.length === 0) {
+          progress.dispose();
+          return;
+        }
       }
+      progress.complete(1, channels.join(", "));
 
-      // 2. Get last tag
+      // 2. Get last tag + current version + check if bump is needed
+      progress.activate(2, "Parsing git history");
       const lastTag = await getLastTag(platform, ctx.cwd);
-
-      // 3. Get current version
       const currentVersion = getCurrentVersion(ctx.cwd);
+      const alreadyReleased = await isVersionReleased(
+        platform.exec.bind(platform),
+        ctx.cwd,
+        currentVersion,
+      );
 
-      // 4. Parse commits since last tag
+      // 3. Parse commits since last tag
       const sinceArg = lastTag ? `${lastTag}..HEAD` : "HEAD~50..HEAD";
       let gitLogOutput: string;
       try {
@@ -51,26 +300,50 @@ export function registerReleaseCommand(platform: Platform): void {
 
       const commits = parseConventionalCommits(gitLogOutput);
       const summary = summarizeChanges(commits);
+      const commitCount = commits.features.length + commits.fixes.length + commits.breaking.length + commits.improvements.length + commits.maintenance.length + commits.other.length;
+      progress.complete(2, `${commitCount} commits since ${lastTag ?? "start"}`);
 
-      // 5. Suggest bump → UI select to confirm/override
-      const suggested = suggestBump(commits);
-      const bumpChoice = await ctx.ui.select(
-        `Version bump (${summary})`,
-        BUMP_OPTIONS,
-        { helpText: `Suggested: ${suggested}` },
-      );
-      if (!bumpChoice) return;
+      // 4. Version resolution — skip bump when local version is unreleased
+      let nextVersion: string;
+      let skipBump: boolean;
 
-      const bump = bumpChoice.split(" — ")[0] as BumpType;
+      if (!alreadyReleased && currentVersion !== "0.0.0") {
+        // Local version hasn't been tagged yet — use it as-is
+        nextVersion = currentVersion;
+        skipBump = true;
+        progress.skip(3, `v${currentVersion} (already set, not yet released)`);
+        notifyInfo(ctx, `Using v${currentVersion}`, "Version not yet released — skipping bump");
+      } else {
+        // Version already released — ask for bump
+        progress.activate(3, "Awaiting version selection");
+        const suggested = suggestBump(commits);
+        const bumpChoice = await ctx.ui.select(
+          `Version bump (${summary})`,
+          BUMP_OPTIONS,
+          { helpText: `Current: ${currentVersion} (released) | Suggested: ${suggested}` },
+        );
+        if (!bumpChoice) {
+          progress.dispose();
+          return;
+        }
 
-      // 6. Compute next version
-      const nextVersion = bumpVersion(currentVersion, bump);
+        const bump = bumpChoice.split(" \u2014 ")[0] as BumpType;
+        nextVersion = bumpVersion(currentVersion, bump);
+        skipBump = false;
+        progress.complete(3, `${currentVersion} → ${nextVersion} (${bump})`);
+      }
 
-      // 7. Build changelog
+      // 5. Build changelog
+      progress.activate(4, "Generating changelog");
       const changelog = buildChangelogMarkdown(commits, nextVersion);
+      progress.complete(4, `${commitCount} entries`);
 
-      // 8. Polish mode → steer prompt to LLM, then return
+      // 6. Polish mode → steer prompt to LLM, then return
       if (isPolish) {
+        progress.skip(5, "Polish mode");
+        progress.skip(6, "Polish mode");
+        progress.dispose();
+
         const releaseCommands = buildReleaseCommands(nextVersion, channels);
         const prompt = buildPolishPrompt({
           changelog,
@@ -93,26 +366,47 @@ export function registerReleaseCommand(platform: Platform): void {
         return;
       }
 
-      // 9. Confirm via UI
-      const confirmLabel = isDryRun ? `[DRY RUN] Ship v${nextVersion}?` : `Ship v${nextVersion}?`;
-      const confirmDetail = [
-        `${currentVersion} → ${nextVersion}`,
-        `Channels: ${channels.join(", ")}`,
-        `Changes: ${summary}`,
-        "",
-        changelog,
-      ].join("\n");
-
-      const confirmed = ctx.ui.confirm
-        ? await ctx.ui.confirm(confirmLabel, confirmDetail)
-        : (await ctx.ui.select(confirmLabel, ["Yes — publish", "No — abort"])) === "Yes — publish";
-
-      if (!confirmed) {
-        notifyInfo(ctx, "Release cancelled", "No changes were made");
-        return;
+      // 7. Confirm via UI — skipped when resuming a staged unreleased release.
+      //    When skipBump is true the user already decided on the version; when
+      //    channels were pre-configured there's nothing left to decide. Asking
+      //    again is friction without benefit. Dry-run always asks because the
+      //    user explicitly opted into preview mode.
+      const isResume = isInProgressRelease({ skipBump, channelsWerePreConfigured, isDryRun });
+
+      if (isResume) {
+        notifyInfo(
+          ctx,
+          `Resuming release v${nextVersion}`,
+          "Version staged and channels configured — proceeding without confirmation",
+        );
+      } else {
+        const confirmLabel = isDryRun ? `[DRY RUN] Ship v${nextVersion}?` : `Ship v${nextVersion}?`;
+        // When skipBump=true, currentVersion === nextVersion — avoid the
+        // misleading "0.5.0 → 0.5.0" display.
+        const versionLine = skipBump
+          ? `v${nextVersion} (staged, not yet released)`
+          : `${currentVersion} → ${nextVersion}`;
+        const confirmDetail = [
+          versionLine,
+          `Channels: ${channels.join(", ")}`,
+          `Changes: ${summary}`,
+          "",
+          changelog,
+        ].join("\n");
+
+        const confirmed = ctx.ui.confirm
+          ? await ctx.ui.confirm(confirmLabel, confirmDetail)
+          : (await ctx.ui.select(confirmLabel, ["Yes \u2014 publish", "No \u2014 abort"])) === "Yes \u2014 publish";
+
+        if (!confirmed) {
+          progress.dispose();
+          notifyInfo(ctx, "Release cancelled", "No changes were made");
+          return;
+        }
       }
 
-      // 10. Execute release
+      // 8. Execute release
+      progress.activate(5, "Starting release execution");
       try {
         const result = await executeRelease({
           exec: platform.exec.bind(platform),
@@ -121,9 +415,39 @@ export function registerReleaseCommand(platform: Platform): void {
           changelog,
           channels,
           dryRun: isDryRun,
+          skipBump,
+          onProgress: progress.executorProgress(),
         });
 
-        // Report result
+        // Mark execution steps based on result
+        if (result.tagCreated && result.pushed) {
+          progress.complete(5, "Tag + push complete");
+        } else if (result.error) {
+          progress.fail(5, result.error);
+        } else {
+          progress.fail(5, `Tag: ${result.tagCreated ? "✓" : "✗"} | Push: ${result.pushed ? "✓" : "✗"}`);
+        }
+
+        // Mark channel publishing
+        if (result.channels.length > 0) {
+          const allOk = result.channels.every((c) => c.success);
+          if (allOk) {
+            progress.complete(6, result.channels.map((c) => c.channel).join(", "));
+          } else {
+            const failedChannels = result.channels.filter((c) => !c.success);
+            progress.fail(6, failedChannels.map((c) => `${c.channel}: ${c.error ?? "failed"}`).join("; "));
+          }
+        } else if (result.error) {
+          progress.skip(6, "Skipped (release failed)");
+        } else {
+          progress.complete(6, "No channels");
+        }
+
+        // Give the user a moment to see the final widget state
+        await new Promise((r) => setTimeout(r, 1500));
+        progress.dispose();
+
+        // Final notification
         const channelSummary = result.channels
           .map((c) => `${c.channel}: ${c.success ? "✓" : `✗ ${c.error ?? "failed"}`}`)
           .join(", ");
@@ -136,21 +460,34 @@ export function registerReleaseCommand(platform: Platform): void {
             `Tag: ${result.tagCreated ? "✓" : "✗"} | Push: ${result.pushed ? "✓" : "✗"} | ${channelSummary}`,
           );
         } else {
-          notifyError(
-            ctx,
-            `Release v${nextVersion} failed`,
-            `Tag: ${result.tagCreated ? "✓" : "✗"} | Push: ${result.pushed ? "✓" : "✗"}`,
-          );
+          // Include the error detail so the user knows WHY it failed
+          const detail = result.error
+            ? result.error
+            : `Tag: ${result.tagCreated ? "✓" : "✗"} | Push: ${result.pushed ? "✓" : "✗"}`;
+          notifyError(ctx, `Release v${nextVersion} failed`, detail);
         }
       } catch (err) {
+        progress.fail(5, err instanceof Error ? err.message : "Unknown error");
+        await new Promise((r) => setTimeout(r, 1500));
+        progress.dispose();
         notifyError(
           ctx,
           "Release failed",
           err instanceof Error ? err.message : String(err),
         );
+      } finally {
+        if (didStash) {
+          const popResult = await platform.exec("git", ["stash", "pop"], { cwd: ctx.cwd });
+          if (popResult.code !== 0) {
+            notifyError(ctx, "Stash pop failed", "Run 'git stash pop' manually to recover your changes");
+          }
+        }
       }
-    },
-  });
+    } catch (err) {
+      progress.dispose();
+      notifyError(ctx, "Release error", err instanceof Error ? err.message : String(err));
+    }
+  })();
 }
 
 async function getLastTag(platform: Platform, cwd: string): Promise<string | null> {
@@ -204,7 +541,7 @@ function buildReleaseCommands(
 ): string[] {
   const commands: string[] = [
     `git add -A`,
-    `git commit -m "release: v${version}"`,
+    `git commit -m "chore(release): v${version}"`,
     `git tag -a v${version} -m "Release v${version}"`,
     `git push origin HEAD --follow-tags`,
   ];

package/src/commands/review.ts

@@ -100,7 +100,7 @@ export function registerReviewCommand(platform: Platform): void {
       const modelConfig = loadModelConfig(platform.paths, ctx.cwd);
       const bridge = createModelBridge(platform);
       const resolved = resolveModelForAction("review", modelRegistry, modelConfig, bridge);
-      if (resolved.source !== "main" && platform.setModel) {
+      if (resolved.source !== "main" && platform.setModel && resolved.model) {
         platform.setModel(resolved.model);
       }
 

package/src/commands/status.ts

@@ -1,34 +1,17 @@
 import type { Platform, PlatformContext } from "../platform/types.js";
-import { findActiveRun, loadAllAgentResults } from "../storage/runs.js";
+import { listPlans } from "../storage/plans.js";
+import { loadConfig } from "../config/loader.js";
 
 export function handleStatus(platform: Platform, ctx: PlatformContext): void {
-  const activeRun = findActiveRun(platform.paths, ctx.cwd);
-  if (!activeRun) {
-    ctx.ui.notify("No active runs — use /supi:run to execute a plan", "info");
-    return;
-  }
-
   void (async () => {
-    const results = loadAllAgentResults(platform.paths, ctx.cwd, activeRun.id);
-    const totalTasks = activeRun.batches.reduce(
-      (sum, b) => sum + b.taskIds.length,
-      0
-    );
-    const doneCount = results.filter((r) => r.status === "done").length;
-    const concernCount = results.filter((r) => r.status === "done_with_concerns").length;
-    const blockedCount = results.filter((r) => r.status === "blocked").length;
-    const currentBatch = activeRun.batches.find((b) => b.status !== "completed");
+    const plans = listPlans(platform.paths, ctx.cwd);
+    const config = loadConfig(platform.paths, ctx.cwd);
 
     const options = [
-      `Run: ${activeRun.id}`,
-      `Status: ${activeRun.status}`,
-      `Plan: ${activeRun.planRef}`,
-      `Profile: ${activeRun.profile}`,
-      `Progress: ${results.length}/${totalTasks} tasks`,
-      `  Done: ${doneCount}`,
-      `  With concerns: ${concernCount}`,
-      `  Blocked: ${blockedCount}`,
-      `Batch: ${currentBatch ? `#${currentBatch.index} (${currentBatch.status})` : "all complete"}`,
+      `Profile: ${config.defaultProfile}`,
+      `Plans: ${plans.length === 0 ? "none" : ""}`,
+      ...plans.map((p) => `  · ${p}`),
+      "",
       "Close",
     ];
 
@@ -40,7 +23,7 @@ export function handleStatus(platform: Platform, ctx: PlatformContext): void {
 
 export function registerStatusCommand(platform: Platform): void {
   platform.registerCommand("supi:status", {
-    description: "Check on running sub-agents and task progress",
+    description: "Show project plans and configuration",
     async handler(_args: string | undefined, ctx: any) {
       handleStatus(platform, ctx);
     },

package/src/commands/supi.ts

@@ -1,33 +1,30 @@
 import type { Platform, PlatformContext } from "../platform/types.js";
 import { loadConfig } from "../config/loader.js";
-import { findActiveRun } from "../storage/runs.js";
 import { loadLatestReport } from "../storage/reports.js";
 import { listPlans } from "../storage/plans.js";
 
 export function handleSupi(platform: Platform, ctx: PlatformContext): void {
   void (async () => {
     const config = loadConfig(platform.paths, ctx.cwd);
-    const activeRun = findActiveRun(platform.paths, ctx.cwd);
     const latestReport = loadLatestReport(platform.paths, ctx.cwd);
     const plans = listPlans(platform.paths, ctx.cwd);
 
     const commands = [
       "/supi:plan     — Start collaborative planning",
-      "/supi:run      — Execute a plan with sub-agents",
       "/supi:review   — Run quality gates",
       "/supi:qa       — E2E product testing with Playwright",
       "/supi:fix-pr   — Fix PR review comments",
       "/supi:release  — Release automation",
       "/supi:config   — Manage configuration",
-      "/supi:status   — Check running tasks",
+      "/supi:status   — Show project status",
       "/supi:doctor   — Run health checks",
       "/supi:update   — Update to latest version",
+      "/supi:context  — Show context breakdown",
     ];
 
     const status = [
       `Profile: ${config.defaultProfile}`,
       `Plans: ${plans.length}`,
-      `Active run: ${activeRun ? activeRun.id : "none"}`,
       `Last review: ${latestReport ? `${latestReport.timestamp.slice(0, 10)} (${latestReport.passed ? "passed" : "failed"})` : "none"}`,
     ];
 

package/src/config/defaults.ts

@@ -4,13 +4,6 @@ import type { SupipowersConfig, Profile } from "../types.js";
 export const DEFAULT_CONFIG: SupipowersConfig = {
   version: "1.0.0",
   defaultProfile: "thorough",
-  orchestration: {
-    maxParallelAgents: 3,
-    maxFixRetries: 2,
-    maxNestingDepth: 2,
-    modelPreference: "auto",
-    taskTimeout: 600_000, // 10 minutes
-  },
   lsp: {
     setupGuide: true,
   },
@@ -51,10 +44,6 @@ export const BUILTIN_PROFILES: Record<string, Profile> = {
       testSuite: false,
       e2e: false,
     },
-    orchestration: {
-      reviewAfterEachBatch: false,
-      finalReview: false,
-    },
   },
   thorough: {
     name: "thorough",
@@ -65,10 +54,6 @@ export const BUILTIN_PROFILES: Record<string, Profile> = {
       testSuite: false,
       e2e: false,
     },
-    orchestration: {
-      reviewAfterEachBatch: true,
-      finalReview: true,
-    },
   },
   "full-regression": {
     name: "full-regression",
@@ -79,9 +64,5 @@ export const BUILTIN_PROFILES: Record<string, Profile> = {
       testSuite: true,
       e2e: true,
     },
-    orchestration: {
-      reviewAfterEachBatch: true,
-      finalReview: true,
-    },
   },
 };