supipowers 2.1.0 → 2.2.1

package/src/commands/fix-pr.ts

@@ -3,7 +3,7 @@ import * as os from "node:os";
 import * as path from "node:path";
 import type { Platform } from "../platform/types.js";
 import type { WorkspaceTarget } from "../types.js";
-import { buildWorkspaceTargetOptionLabel, parseTargetArg, selectWorkspaceTarget, stripCliArg, tokenizeCliArgs } from "../workspace/selector.js";
+import { buildWorkspaceTargetOptionLabel, parseTargetArg, stripCliArg, tokenizeCliArgs } from "../workspace/selector.js";
 import { resolvePackageManager } from "../workspace/package-manager.js";
 import { resolveRepoRoot } from "../workspace/repo-root.js";
 import { discoverWorkspaceTargets } from "../workspace/targets.js";
@@ -31,6 +31,45 @@ import { loadModelConfig } from "../config/model-config.js";
 import { detectBotReviewers } from "../fix-pr/bot-detector.js";
 import { runFixPrAssessment, groupAssessmentsIntoBatches } from "../fix-pr/assessment.js";
 import { updateFixPrSession } from "../storage/fix-pr-sessions.js";
+import { createWorkflowProgress } from "../platform/progress.js";
+
+
+const FIX_PR_ASSESSMENT_TIMEOUT_MS = 5 * 60 * 1_000;
+const FIX_PR_ASSESSMENT_COMMENTS_PER_BATCH = 12;
+
+const FIX_PR_STEPS = [
+  { key: "fetch-comments", label: "Fetch PR comments" },
+  { key: "select-target", label: "Select target" },
+  { key: "prepare-session", label: "Prepare session" },
+  { key: "llm-assessment", label: "LLM assessment" },
+  { key: "send-prompt", label: "Send fix prompt" },
+] as const;
+
+function createFixPrProgress(ctx: any) {
+  const progress = createWorkflowProgress(ctx.ui, {
+    title: "supi:fix-pr",
+    statusKey: "supi-fix-pr",
+    statusLabel: "Fixing PR...",
+    widgetKey: "supi-fix-pr",
+    clearStatusKeys: ["supi-model"],
+    steps: [...FIX_PR_STEPS],
+  });
+
+  return {
+    activate(stepIndex: number, detail?: string): void {
+      progress.activate(FIX_PR_STEPS[stepIndex]!.key, detail);
+    },
+    complete(stepIndex: number, detail?: string): void {
+      progress.complete(FIX_PR_STEPS[stepIndex]!.key, detail);
+    },
+    fail(stepIndex: number, detail?: string): void {
+      progress.fail(FIX_PR_STEPS[stepIndex]!.key, detail);
+    },
+    dispose(): void {
+      progress.dispose();
+    },
+  };
+}
 
 modelRegistry.register({
   id: "fix-pr",
@@ -47,6 +86,7 @@ modelRegistry.register({
   harnessRoleHint: "default",
 });
 
+
 function getScriptsDir(): string {
   return path.join(moduleDir(import.meta.url), "..", "fix-pr", "scripts");
 }
@@ -91,6 +131,12 @@ function formatUnscopedCommentCount(count: number): string {
   return `${formatCommentCount(count)} without file path`;
 }
 
+type FixPrSelectedTarget =
+  | { kind: "workspace"; target: WorkspaceTarget }
+  | { kind: "all"; target: WorkspaceTarget };
+
+const ALL_FIX_PR_TARGET_ID = "all";
+
 function buildCommentTargetOptions(
   targets: readonly WorkspaceTarget[],
   commentsByTargetId: ReadonlyMap<string, readonly PrComment[]>,
@@ -109,6 +155,43 @@ function buildCommentTargetOptions(
   });
 }
 
+function createAllCommentsTarget(repoRoot: string, packageManager: WorkspaceTarget["packageManager"]): WorkspaceTarget {
+  return {
+    id: ALL_FIX_PR_TARGET_ID,
+    name: "all",
+    kind: "workspace",
+    repoRoot,
+    packageDir: repoRoot,
+    manifestPath: path.join(repoRoot, "package.json"),
+    relativeDir: ALL_FIX_PR_TARGET_ID,
+    version: "0.0.0",
+    private: true,
+    packageManager,
+  };
+}
+
+function describeFixPrSelectedTarget(selected: FixPrSelectedTarget): string {
+  return selected.kind === "all" ? "all targets" : describeTarget(selected.target);
+}
+
+function getSelectedTargetComments(
+  selected: FixPrSelectedTarget,
+  commentsByTargetId: ReadonlyMap<string, readonly PrComment[]>,
+  unscopedComments: readonly PrComment[],
+): readonly PrComment[] {
+  if (selected.kind === "workspace") {
+    return commentsByTargetId.get(selected.target.id) ?? [];
+  }
+
+  const comments: PrComment[] = [];
+  for (const targetComments of commentsByTargetId.values()) {
+    comments.push(...targetComments);
+  }
+  comments.push(...unscopedComments);
+  return comments;
+}
+
+
 function countUnresolvedAssessments(assessment: FixPrAssessmentBatch): number {
   return assessment.assessments.filter((item: FixPrAssessmentBatch["assessments"][number]) => item.verdict !== "apply").length;
 }
@@ -211,14 +294,18 @@ export function registerFixPrCommand(platform: Platform): void {
         return;
       }
 
+      const progress = createFixPrProgress(ctx);
       const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "supi-fix-pr-"));
       try {
+        progress.activate(0, `PR #${prNumber}`);
         const fetchedCommentsPath = path.join(tempDir, "comments.jsonl");
         const fetchError = await fetchPrComments(platform, repo, prNumber, fetchedCommentsPath, repoRoot);
         if (fetchError) {
+          progress.fail(0, "failed");
           notifyError(ctx, "Failed to fetch PR comments", fetchError);
           return;
         }
+        progress.complete(0, `PR #${prNumber}`);
 
         const fetchedComments = fs.readFileSync(fetchedCommentsPath, "utf-8").trim();
         if (!fetchedComments) {
@@ -238,36 +325,74 @@ export function registerFixPrCommand(platform: Platform): void {
           clusteredComments.commentsByTargetId,
         );
 
-        if (targetOptions.length === 0) {
-          const detail = clusteredComments.unscopedComments.length > 0
-            ? `PR comments were fetched but only ${formatUnscopedCommentCount(clusteredComments.unscopedComments.length)} could not be assigned to a workspace target`
-            : "PR comments were fetched but could not be assigned to a package or root target";
-          notifyWarning(ctx, "No actionable comments found", detail);
+        const allTarget = createAllCommentsTarget(repoRoot, packageManager.id);
+        const allOption = {
+          target: allTarget,
+          changed: true,
+          label: buildWorkspaceTargetOptionLabel(
+            { target: allTarget, changed: true },
+            [formatCommentCount(parsedComments.length)],
+          ),
+        };
+
+        if (targetOptions.length === 0 && clusteredComments.unscopedComments.length === 0) {
+          notifyWarning(ctx, "No actionable comments found", "PR comments were fetched but could not be assigned to a package or root target");
           return;
         }
 
-        if (!requestedTarget && !ctx.hasUI && targetOptions.length > 1) {
-          notifyError(ctx, "Multiple comment targets found", buildAvailableTargetDetail(targetOptions, clusteredComments.unscopedComments.length));
-          return;
+        progress.activate(1, `${formatCommentCount(parsedComments.length)}`);
+        let selected: FixPrSelectedTarget | null = null;
+        if (requestedTarget === ALL_FIX_PR_TARGET_ID) {
+          selected = { kind: "all", target: allTarget };
+        } else if (requestedTarget) {
+          const target = targetOptions
+            .map((option) => option.target)
+            .find((optionTarget) => optionTarget.id === requestedTarget || optionTarget.name === requestedTarget);
+          selected = target ? { kind: "workspace", target } : null;
+        } else if (!ctx.hasUI) {
+          selected = { kind: "all", target: allTarget };
+        } else {
+          const labels = [
+            allOption.label,
+            ...targetOptions.map((option) => option.label ?? buildWorkspaceTargetOptionLabel(option)),
+          ];
+          const choice = await ctx.ui.select("Fix-PR target", labels, {
+            helpText: "Select all comments or one target to process for this run",
+          });
+          if (!choice) {
+            progress.fail(1, "cancelled");
+            return;
+          }
+          const selectedIndex = labels.indexOf(choice);
+          selected = selectedIndex === 0
+            ? { kind: "all", target: allTarget }
+            : targetOptions[selectedIndex - 1]
+              ? { kind: "workspace", target: targetOptions[selectedIndex - 1].target }
+              : null;
         }
 
-        const selectedTarget = await selectWorkspaceTarget(ctx, targetOptions, requestedTarget, {
-          title: "Fix-PR target",
-          helpText: "Select one target to process for this run",
-        });
-        if (!selectedTarget) {
+        if (!selected) {
           if (requestedTarget) {
             notifyError(ctx, "Target has no review comments", buildAvailableTargetDetail(targetOptions, clusteredComments.unscopedComments.length));
           }
+          progress.fail(1, "empty");
           return;
         }
+        progress.complete(1, describeFixPrSelectedTarget(selected));
 
-        const selectedComments = clusteredComments.commentsByTargetId.get(selectedTarget.id) ?? [];
+        const selectedTarget = selected.target;
+        const selectedComments = getSelectedTargetComments(
+          selected,
+          clusteredComments.commentsByTargetId,
+          clusteredComments.unscopedComments,
+        );
         if (selectedComments.length === 0) {
           notifyInfo(ctx, "No comments for selected target", `${selectedTarget.id} has no actionable comments in this PR snapshot`);
           return;
         }
 
+        progress.activate(2, `${formatCommentCount(selectedComments.length)}`);
+
         let activeSession = findActiveFixPrSession(platform.paths, selectedTarget, repo, prNumber);
         if (activeSession && ctx.hasUI) {
           const choice = await ctx.ui.select(
@@ -278,7 +403,10 @@ export function registerFixPrCommand(platform: Platform): void {
             ],
             { helpText: "Select session · Esc to cancel" },
           );
-          if (!choice) return;
+          if (!choice) {
+            progress.fail(2, "cancelled");
+            return;
+          }
           if (choice.startsWith("Start new")) activeSession = null;
         }
 
@@ -328,12 +456,17 @@ export function registerFixPrCommand(platform: Platform): void {
 
         const taskResolved = resolveModelForAction("task", modelRegistry, modelConfig, bridge);
         const taskModel = taskResolved.model ?? resolved.model ?? "claude-sonnet-4-6";
-        const deferredCommentsSummary = buildDeferredCommentsSummary(
-          targetOptions,
-          clusteredComments.commentsByTargetId,
-          selectedTarget,
-          clusteredComments.unscopedComments.length,
-        );
+        const deferredCommentsSummary = selected.kind === "all"
+          ? null
+          : buildDeferredCommentsSummary(
+            targetOptions,
+            clusteredComments.commentsByTargetId,
+            selectedTarget,
+            clusteredComments.unscopedComments.length,
+          );
+        progress.complete(2, activeSession ? `resume ${ledger.id}` : `new ${ledger.id}`);
+
+        progress.activate(3, `${formatCommentCount(selectedComments.length)}`);
 
         const assessmentResult = await runFixPrAssessment({
           createAgentSession: platform.createAgentSession,
@@ -342,17 +475,22 @@ export function registerFixPrCommand(platform: Platform): void {
           comments: selectedComments,
           repo,
           prNumber,
-          selectedTargetLabel: describeTarget(selectedTarget),
+          selectedTargetLabel: describeFixPrSelectedTarget(selected),
           model: resolved.model,
           thinkingLevel: resolved.thinkingLevel,
+          timeoutMs: FIX_PR_ASSESSMENT_TIMEOUT_MS,
+          maxCommentsPerBatch: FIX_PR_ASSESSMENT_COMMENTS_PER_BATCH,
         });
         if (assessmentResult.status === "blocked") {
+          progress.fail(3, "blocked");
           notifyError(ctx, "Fix-PR assessment failed", assessmentResult.error);
           return;
         }
+        progress.complete(3, `${formatCommentCount(assessmentResult.output.assessments.length)} assessed`);
         const assessment = assessmentResult.output;
         const unresolvedAssessmentCount = countUnresolvedAssessments(assessment);
         const workBatches = groupAssessmentsIntoBatches(assessment);
+        progress.activate(4, `${workBatches.length} batch${workBatches.length === 1 ? "" : "es"}`);
         ledger.assessment = assessment;
         updateFixPrSession(platform.paths, selectedTarget, ledger);
 
@@ -360,7 +498,7 @@ export function registerFixPrCommand(platform: Platform): void {
           notifyWarning(
             ctx,
             "Unresolved comments remain",
-            `${formatCommentCount(unresolvedAssessmentCount)} for ${describeTarget(selectedTarget)} still need rejection or investigation handling before this run can be considered complete.`,
+            `${formatCommentCount(unresolvedAssessmentCount)} for ${describeFixPrSelectedTarget(selected)} still need rejection or investigation handling before this run can be considered complete.`,
           );
         }
 
@@ -374,7 +512,7 @@ export function registerFixPrCommand(platform: Platform): void {
           iteration: ledger.iteration,
           skillContent,
           taskModel,
-          selectedTargetLabel: describeTarget(selectedTarget),
+          selectedTargetLabel: describeFixPrSelectedTarget(selected),
           deferredCommentsSummary,
           assessment,
           workBatches,
@@ -388,14 +526,16 @@ export function registerFixPrCommand(platform: Platform): void {
           },
           { deliverAs: "steer", triggerTurn: true },
         );
+        progress.complete(4, "sent");
 
-        const detailParts = [`${formatCommentCount(selectedComments.length)} for ${describeTarget(selectedTarget)}`];
+        const detailParts = [`${formatCommentCount(selectedComments.length)} for ${describeFixPrSelectedTarget(selected)}`];
         if (deferredCommentsSummary) {
           detailParts.push(`deferred: ${deferredCommentsSummary}`);
         }
         notifyInfo(ctx, `Fix-PR started: PR #${prNumber}`, `${detailParts.join(" | ")} | session ${ledger.id}`);
       } finally {
         fs.rmSync(tempDir, { recursive: true, force: true });
+        progress.dispose();
       }
     },
   });

package/src/commands/optimize-context.ts

@@ -18,9 +18,11 @@ import {
 import type {
   ManualOptimizationAction,
   OptimizationPlan,
+  WriteCommandAction,
   WriteRuleAction,
+  WriteExtensionAction,
 } from "../context/startup-optimizer.js";
-import { parseManagedRule, renderManagedRule } from "../context/rule-renderer.js";
+import { parseManagedCommand, parseManagedExtension, parseManagedRule, renderManagedCommand, renderManagedExtension, renderManagedRule } from "../context/rule-renderer.js";
 import { DEFAULT_TOKENIGNORE_ENTRIES, mergeManagedTokenignore } from "../context/tokenignore.js";
 import {
   parseStartupOptimizerManifest,
@@ -142,6 +144,20 @@ async function runCheck(
     }
   }
 
+  const commandFiles: Record<string, string | null> = {};
+  if (manifest) {
+    for (const command of manifest.commands) {
+      commandFiles[command.path] = readOptionalFile(path.join(ctx.cwd, command.path));
+    }
+  }
+
+  const extensionFiles: Record<string, string | null> = {};
+  if (manifest) {
+    for (const extension of manifest.extensions) {
+      extensionFiles[extension.path] = readOptionalFile(path.join(ctx.cwd, extension.path));
+    }
+  }
+
   const currentSkills: ParsedSkill[] = currentPrompt ? parseIndividualSkills(currentPrompt) : [];
   const currentSections: PromptSection[] = currentPrompt ? parseSystemPrompt(currentPrompt) : [];
 
@@ -149,6 +165,8 @@ async function runCheck(
     manifestPath,
     manifestText,
     ruleFiles,
+    commandFiles,
+    extensionFiles,
     tokenignorePath,
     tokenignoreText: readOptionalFile(tokenignorePath),
     currentPrompt,
@@ -232,17 +250,23 @@ async function showDryRun(ctx: PlatformContext, plan: OptimizationPlan): Promise
 
 function buildPlanPreview(plan: OptimizationPlan): string[] {
   const writeRuleCount = plan.actions.filter((action) => action.kind === "write-rule").length;
-  const manualCount = plan.actions.filter((action) => action.kind !== "write-rule").length;
+  const writeCommandCount = plan.actions.filter((action) => action.kind === "write-command").length;
+  const writeExtensionCount = plan.actions.filter((action) => action.kind === "write-extension").length;
+  const manualCount = plan.actions.filter((action) => action.kind !== "write-rule" && action.kind !== "write-command" && action.kind !== "write-extension").length;
   const lines = [
     `Source set: ${plan.sourceSetHash.slice(0, 12)}`,
     `Current: ~${formatTokens(Math.ceil(plan.beforeBytes / 4))} tokens  |  Estimated after planned removals: ~${formatTokens(Math.ceil(plan.estimatedAfterBytes / 4))} tokens`,
-    `Actions: ${writeRuleCount} write-rule, ${manualCount} manual`,
+    `Actions: ${writeRuleCount} write-rule, ${writeCommandCount} write-command, ${writeExtensionCount} write-extension, ${manualCount} manual`,
     "",
   ];
 
   for (const action of plan.actions) {
     if (action.kind === "write-rule") {
       lines.push(`write-rule ${action.mode}: ${action.targetPath}`);
+    } else if (action.kind === "write-command") {
+      lines.push(`write-command: /${action.commandName} -> ${action.targetPath}`);
+    } else if (action.kind === "write-extension") {
+      lines.push(`write-extension: ${action.extensionName} -> ${action.targetPath}`);
     } else if (action.kind === "manual-disable") {
       lines.push(`manual-disable ${action.sourceName}: ${action.reason}`);
     } else {
@@ -268,9 +292,14 @@ async function applyOptimizationPlan(
   }
 
   const writeRules = plan.actions.filter((action): action is WriteRuleAction => action.kind === "write-rule");
-  const preflight = preflightRuleWrites(ctx.cwd, writeRules);
-  if (preflight.conflicts.length > 0) {
-    ctx.ui.notify(`Apply blocked: ${preflight.conflicts.join("; ")}`, "error");
+  const writeCommands = plan.actions.filter((action): action is WriteCommandAction => action.kind === "write-command");
+  const writeExtensions = plan.actions.filter((action): action is WriteExtensionAction => action.kind === "write-extension");
+  const rulePreflight = preflightRuleWrites(ctx.cwd, writeRules);
+  const commandPreflight = preflightCommandWrites(ctx.cwd, writeCommands);
+  const extensionPreflight = preflightExtensionWrites(ctx.cwd, writeExtensions);
+  const preflightConflicts = [...rulePreflight.conflicts, ...commandPreflight.conflicts, ...extensionPreflight.conflicts];
+  if (preflightConflicts.length > 0) {
+    ctx.ui.notify(`Apply blocked: ${preflightConflicts.join("; ")}`, "error");
     return;
   }
 
@@ -279,7 +308,7 @@ async function applyOptimizationPlan(
     return;
   }
 
-  const summary = buildApplySummary(plan, preflight.updates);
+  const summary = buildApplySummary(plan, [...rulePreflight.updates, ...commandPreflight.updates, ...extensionPreflight.updates]);
   const accepted = await confirmApply(ctx, summary);
   if (!accepted) {
     ctx.ui.notify("Apply cancelled.", "info");
@@ -299,6 +328,18 @@ async function applyOptimizationPlan(
       fs.writeFileSync(target, renderManagedRule(action));
     }
 
+    for (const action of writeCommands) {
+      const target = absoluteRulePath(ctx.cwd, action.targetPath);
+      fs.mkdirSync(path.dirname(target), { recursive: true });
+      fs.writeFileSync(target, renderManagedCommand(action));
+    }
+
+    for (const action of writeExtensions) {
+      const target = absoluteRulePath(ctx.cwd, action.targetPath);
+      fs.mkdirSync(path.dirname(target), { recursive: true });
+      fs.writeFileSync(target, renderManagedExtension(action));
+    }
+
     fs.mkdirSync(path.dirname(tokenignorePath), { recursive: true });
     fs.writeFileSync(tokenignorePath, tokenignore.content);
 
@@ -315,7 +356,7 @@ async function applyOptimizationPlan(
   // process can't see the just-written .omp/rules without a full restart.
   // Be honest about this rather than silently calling reload() and lying.
   ctx.ui.notify(
-    "Applied deterministic context migration. Restart OMP so the new managed rules in .omp/rules are picked up by rule discovery, then disable the original sources and run /supi:optimize-context --check to validate runtime savings.",
+    "Applied deterministic context migration. Restart OMP so new managed rules in .omp/rules, commands in .omp/commands, and the runbook extension in .omp/extensions are picked up by discovery, then disable the original sources and run /supi:optimize-context --check to validate runtime savings.",
     "info",
   );
 }
@@ -358,11 +399,73 @@ function preflightRuleWrites(
       conflicts.push(`${action.targetPath} is malformed: ${parsed.error}`);
       continue;
     }
-    if (
-      parsed.metadata.sourceHash !== action.sourceHash ||
-      parsed.metadata.sourceId !== action.sourceId ||
-      parsed.metadata.mode !== action.mode
-    ) {
+    if (fs.readFileSync(target, "utf-8") !== renderManagedRule(action)) {
+      updates.push(action.targetPath);
+    }
+  }
+
+  return { conflicts, updates };
+}
+
+function preflightCommandWrites(
+  cwd: string,
+  actions: WriteCommandAction[],
+): { conflicts: string[]; updates: string[] } {
+  const conflicts: string[] = [];
+  const updates: string[] = [];
+
+  for (const action of actions) {
+    const target = absoluteRulePath(cwd, action.targetPath);
+    if (!fs.existsSync(target)) continue;
+    const stat = fs.statSync(target);
+    if (!stat.isFile()) {
+      conflicts.push(`${action.targetPath} exists and is not a file`);
+      continue;
+    }
+
+    const parsed = parseManagedCommand(fs.readFileSync(target, "utf-8"));
+    if (parsed.status === "unmanaged") {
+      conflicts.push(`${action.targetPath} is unmanaged`);
+      continue;
+    }
+    if (parsed.status === "malformed") {
+      conflicts.push(`${action.targetPath} is malformed: ${parsed.error}`);
+      continue;
+    }
+    if (fs.readFileSync(target, "utf-8") !== renderManagedCommand(action)) {
+      updates.push(action.targetPath);
+    }
+  }
+
+  return { conflicts, updates };
+}
+
+function preflightExtensionWrites(
+  cwd: string,
+  actions: WriteExtensionAction[],
+): { conflicts: string[]; updates: string[] } {
+  const conflicts: string[] = [];
+  const updates: string[] = [];
+
+  for (const action of actions) {
+    const target = absoluteRulePath(cwd, action.targetPath);
+    if (!fs.existsSync(target)) continue;
+    const stat = fs.statSync(target);
+    if (!stat.isFile()) {
+      conflicts.push(`${action.targetPath} exists and is not a file`);
+      continue;
+    }
+
+    const parsed = parseManagedExtension(fs.readFileSync(target, "utf-8"));
+    if (parsed.status === "unmanaged") {
+      conflicts.push(`${action.targetPath} is unmanaged`);
+      continue;
+    }
+    if (parsed.status === "malformed") {
+      conflicts.push(`${action.targetPath} is malformed: ${parsed.error}`);
+      continue;
+    }
+    if (fs.readFileSync(target, "utf-8") !== renderManagedExtension(action)) {
       updates.push(action.targetPath);
     }
   }
@@ -370,11 +473,16 @@ function preflightRuleWrites(
   return { conflicts, updates };
 }
 
+
 function buildApplySummary(plan: OptimizationPlan, updates: string[]): string {
   const writeRuleCount = plan.actions.filter((action) => action.kind === "write-rule").length;
-  const manualCount = plan.actions.filter((action) => action.kind !== "write-rule").length;
+  const writeCommandCount = plan.actions.filter((action) => action.kind === "write-command").length;
+  const writeExtensionCount = plan.actions.filter((action) => action.kind === "write-extension").length;
+  const manualCount = plan.actions.filter((action) => action.kind !== "write-rule" && action.kind !== "write-command" && action.kind !== "write-extension").length;
   const lines = [
     `Write ${writeRuleCount} managed rule file${writeRuleCount === 1 ? "" : "s"}.`,
+    `Write ${writeCommandCount} managed command file${writeCommandCount === 1 ? "" : "s"}.`,
+    `Write ${writeExtensionCount} managed extension file${writeExtensionCount === 1 ? "" : "s"}.`,
     `Merge ${DEFAULT_TOKENIGNORE_ENTRIES.length} managed .tokenignore entries.`,
     `Record ${manualCount} manual follow-up action${manualCount === 1 ? "" : "s"}.`,
     `Estimated savings after planned removals: ~${formatTokens(Math.ceil(plan.estimatedSavedBytes / 4))} tokens.`,
@@ -382,7 +490,7 @@ function buildApplySummary(plan: OptimizationPlan, updates: string[]): string {
   if (updates.length > 0) {
     lines.push(`Managed update candidate${updates.length === 1 ? "" : "s"}: ${updates.join(", ")}`);
   }
-  lines.push("Manifest is written last after managed rule and tokenignore writes succeed.");
+  lines.push("Manifest is written last after managed rule, command, extension, and tokenignore writes succeed.");
   return lines.join("\n");
 }
 
@@ -406,8 +514,35 @@ function buildManifest(plan: OptimizationPlan): StartupOptimizerManifest {
       slug: action.slug,
       sourceBytes: action.sourceBytes,
       ...(action.condition ? { condition: action.condition } : {}),
+      ...(action.triggers ? { triggers: action.triggers } : {}),
+      ...(action.scope ? { scope: action.scope } : {}),
       ...(action.description ? { description: action.description } : {}),
     }));
+  const commands = plan.actions
+    .filter((action): action is WriteCommandAction => action.kind === "write-command")
+    .map((action) => ({
+      path: action.targetPath,
+      sourceId: action.sourceId,
+      sourceName: action.sourceName,
+      sourceHash: action.sourceHash,
+      slug: action.slug,
+      commandName: action.commandName,
+      sourceBytes: action.sourceBytes,
+      ...(action.description ? { description: action.description } : {}),
+    }));
+  const extensions = plan.actions
+    .filter((action): action is WriteExtensionAction => action.kind === "write-extension")
+    .map((action) => ({
+      path: action.targetPath,
+      sourceId: action.sourceId,
+      sourceName: action.sourceName,
+      sourceHash: action.sourceHash,
+      slug: action.slug,
+      extensionName: action.extensionName,
+      sourceBytes: action.sourceBytes,
+    }));
+
+
 
   return {
     version: 1,
@@ -417,12 +552,14 @@ function buildManifest(plan: OptimizationPlan): StartupOptimizerManifest {
     estimatedAfterBytes: plan.estimatedAfterBytes,
     estimatedSavedBytes: plan.estimatedSavedBytes,
     rules,
+    commands,
+    extensions,
     tokenignore: {
       path: ".omp/supipowers/.tokenignore",
       entries: tokenignore.entries,
       hash: tokenignore.hash,
     },
-    manualActions: plan.actions.filter((action): action is ManualOptimizationAction => action.kind !== "write-rule"),
+    manualActions: plan.actions.filter((action): action is ManualOptimizationAction => action.kind !== "write-rule" && action.kind !== "write-command" && action.kind !== "write-extension"),
   };
 }