supipowers 2.0.2 → 2.2.0

package/README.md

@@ -23,7 +23,7 @@ Run the interactive installer:
 bunx supipowers
 ```
 
-The installer detects Pi (`~/.pi`) and OMP (`~/.omp`) — when both are present it offers a multiselect to install to one or both. It registers the extension, removes legacy external context-mode MCP registrations from `agent/mcp.json` and cleans up the old `settings/mcp.json` if present, and can install missing optional tooling such as LSP servers, `mcpc`, and Playwright CLI.
+The installer detects Pi (`~/.pi`) and OMP (`~/.omp`) — when both are present it offers a multiselect to install to one or both. It registers the extension, removes legacy external context-mode MCP registrations from `agent/mcp.json` and cleans up the old `settings/mcp.json` if present, and can install missing optional tooling such as LSP servers and Playwright CLI.
 
 > [!TIP]
 > Run `/supi:update` at any time to upgrade to the latest version, or `/supi:doctor` to check your setup.
@@ -42,7 +42,6 @@ The installer scans for these and offers to install missing tooling where it can
 
 | Dependency                            | What it enables                                                       |
 | ------------------------------------- | --------------------------------------------------------------------- |
-| [mcpc](https://github.com/apify/mcpc) | MCP server management via `/supi:mcp`                                 |
 | `typescript-language-server`          | TypeScript/JS diagnostics and references in review gates              |
 | `pyright`                             | Python type checking                                                  |
 | `rust-analyzer`                       | Rust language server                                                  |
@@ -70,7 +69,6 @@ The installer scans for these and offers to install missing tooling where it can
 | `/supi:model`            | Configure model assignments per action (plan, review, qa…)    |
 | `/supi:context`          | Show current context window usage and system prompt breakdown |
 | `/supi:optimize-context` | Analyze loaded prompt/context usage and suggest reductions    |
-| `/supi:mcp`              | Manage MCP servers (connect, disconnect, migrate)             |
 | `/supi:config`           | Interactive settings TUI                                      |
 | `/supi:status`           | Show project plans and configuration summary                  |
 | `/supi:doctor`           | Diagnose extension health and missing dependencies            |
@@ -82,11 +80,11 @@ The installer scans for these and offers to install missing tooling where it can
 | `/supi:memory`           | Manage native MemPalace memory integration (`status`, `setup`) |
 | `/supi:clear`            | Clear metrics, cache, session knowledge, and memory           |
 
-Most commands steer the AI session. These are TUI-only — they open native dialogs without triggering the AI: `/supi`, `/supi:config`, `/supi:status`, `/supi:review`, `/supi:update`, `/supi:doctor`, `/supi:mcp`, `/supi:model`, `/supi:context`, `/supi:optimize-context`, `/supi:commit`, `/supi:release`, `/supi:checks`, `/supi:agents`, `/supi:ultraplan`, `/supi:harness`, `/supi:memory`, `/supi:clear`.
+Most commands steer the AI session. These are TUI-only — they open native dialogs without triggering the AI: `/supi`, `/supi:config`, `/supi:status`, `/supi:review`, `/supi:update`, `/supi:doctor`, `/supi:model`, `/supi:context`, `/supi:optimize-context`, `/supi:commit`, `/supi:release`, `/supi:checks`, `/supi:agents`, `/supi:ultraplan`, `/supi:harness`, `/supi:memory`, `/supi:clear`.
 
 ## How it works
 
-**Planning.** `/supi:plan` steers the AI through planning phases (scope → decompose → estimate → verify), saves the result to `.omp/supipowers/plans/`, and presents an approval UI. On approval, tasks execute in the same session.
+**Planning.** `/supi:plan` steers the AI through planning phases (Explore → Clarify → Brainstorm → Design & Save → Review Loop → User Gate → Plan), saves the result to `.omp/supipowers/plans/`, and presents an approval UI. On approval, tasks execute in the same session.
 
 **Quality gates.** `/supi:checks` runs deterministic quality gates. Six gates are available: `lsp-diagnostics`, `lint`, `typecheck`, `format`, `test-suite`, and `build`. Each gate can be enabled independently via `/supi:config` or the shared repository config at `.omp/supipowers/config.json`. In monorepos, `/supi:checks` defaults to `All`, which runs the root target plus every workspace target sequentially; use `--target <package>` to narrow the run or `--target all` to request the batch mode explicitly. Gates report issues with severity levels.
 
@@ -127,7 +125,6 @@ Use `/supi:agents` to inspect the merged set that will actually run.
 | Release automation                    | ✅         | ❌               |
 | Commit workflow                       | ✅         | ❌               |
 | Context-window optimizations          | ✅         | ❌               |
-| MCP server management through mcpc    | ✅         | ❌               |
 | Git worktree workflow                 | ❌         | ✅               |
 
 ## Quality gates
@@ -161,6 +158,8 @@ Configuration uses built-in defaults plus two user-managed override layers:
 
 `/supi:config` exposes only `Global` and `Repository`. In monorepos, the repository config is shared across every workspace; there are no per-workspace Supipowers config files for general settings.
 
+MemPalace hook timeouts are configured under `mempalace.timeouts`. Keep `hookMs` at or above `6000` when `mempalace.hooks.autoSearchOnPrompt` is enabled; MemPalace search can now pause before retrying a transient index lookup. The built-in default is `10000`.
+
 ## Release channels
 
 Three built-in channels are available: `github` (GitHub Release via `gh` CLI), `gitlab` (GitLab Release via `glab` CLI), and `gitea` (Gitea Release via `tea` CLI). Channels are selected per-project in `release.channels`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "supipowers",
-  "version": "2.0.2",
+  "version": "2.2.0",
   "description": "Workflow extension for OMP coding agents.",
   "type": "module",
   "scripts": {
@@ -9,9 +9,11 @@
     "test:watch": "bun test --timeout 20000 --watch tests/",
     "test:evals": "bun test --timeout 20000 tests/evals/",
     "build": "tsc -p tsconfig.build.json",
+    "ci": "bun run typecheck && bun run test",
     "install:visual-server": "npm --prefix src/visual/scripts ci --ignore-scripts --no-audit --no-fund",
     "postinstall": "bun run install:visual-server",
-    "prepare": "git config core.hooksPath hooks || true"
+    "prepare": "git config core.hooksPath hooks || true",
+    "dev-install": "bun run bin/dev-install.ts"
   },
   "engines": {
     "bun": ">=1.3.10"

package/skills/harness/SKILL.md

@@ -78,6 +78,7 @@ Scorecard has lenient + strict scores (0–100). Strict counts `wontfix` items a
 - `/supi:harness resolve <id>` — mark an entry resolved.
 - `/supi:harness backlog` — list every open entry.
 - `/supi:harness score` — recompute and display the score.
+- `/supi:harness pr-comment [--dry-run] [--pr=N] [--repo=owner/repo] [--session=<id>] [--mode=every-push|on-status-change]` — render (or post) the sticky PR comment for the latest validate report. See `docs/supipowers/harness/pr-comment.md`.
 
 ## Conventions you MUST follow
 

package/src/bootstrap.ts

@@ -13,9 +13,7 @@ import { registerQaCommand } from "./commands/qa.js";
 import { registerReleaseCommand, handleRelease } from "./commands/release.js";
 import { registerUpdateCommand, handleUpdate } from "./commands/update.js";
 import { registerDoctorCommand, handleDoctor } from "./commands/doctor.js";
-import { registerMcpCommand, handleMcp, handleMcpCli, parseCliArgs } from "./commands/mcp.js";
 import { registerModelCommand, handleModel } from "./commands/model.js";
-import { executeManagerAction } from "./mcp/manager-tool.js";
 import { registerFixPrCommand } from "./commands/fix-pr.js";
 import { registerContextCommand, handleContext } from "./commands/context.js";
 import { registerOptimizeContextCommand, handleOptimizeContext } from "./commands/optimize-context.js";
@@ -30,10 +28,6 @@ import { registerHarnessPipelineTools } from "./harness/tools.js";
 import { registerHarnessHooks } from "./harness/hooks/register.js";
 import { loadConfig } from "./config/loader.js";
 import { registerContextModeHooks } from "./context-mode/hooks.js";
-import { loadMcpRegistry } from "./mcp/config.js";
-import { McpcClient } from "./mcp/mcpc.js";
-import { parseTags } from "./mcp/activation.js";
-import { initializeMcpServers, shutdownMcpServers } from "./mcp/lifecycle.js";
 import { registerPlanApprovalHook } from "./planning/approval-flow.js";
 import { registerPlanningSystemPromptHook } from "./planning/system-prompt.js";
 import { registerPlanningAskTool, registerPlanningAskToolGuard } from "./planning/planning-ask-tool.js";
@@ -49,6 +43,7 @@ import { registerUltraPlanAuthoringTool } from "./ultraplan/authoring-tool.js";
 import { registerUltraPlanAuthoringPipelineTools } from "./ultraplan/authoring/authoring-tools.js";
 import { registerActiveToolController } from "./tool-catalog/active-tool-controller.js";
 import { registerMempalaceHooks } from "./mempalace/hooks.js";
+import { registerRunbookCommand, handleRunbook } from "./commands/runbook.js";
 import { registerMempalaceTool } from "./mempalace/tool.js";
 
 // TUI-only commands — intercepted at the input level to prevent
@@ -60,7 +55,6 @@ const TUI_COMMANDS: Record<string, (platform: Platform, ctx: any, args?: string)
   "supi:review": (platform, ctx, args) => handleAiReview(platform, ctx, args),
   "supi:update": (platform, ctx) => handleUpdate(platform, ctx),
   "supi:doctor": (platform, ctx) => handleDoctor(platform, ctx),
-  "supi:mcp": (platform, ctx) => handleMcp(platform, ctx),
   "supi:model": (platform, ctx) => handleModel(platform, ctx),
   "supi:context": (platform, ctx) => handleContext(platform, ctx),
   "supi:optimize-context": (platform, ctx, args) => handleOptimizeContext(platform, ctx, args),
@@ -72,10 +66,9 @@ const TUI_COMMANDS: Record<string, (platform: Platform, ctx: any, args?: string)
   "supi:ultraplan": (platform, ctx, args) => handleUltraplan(platform, ctx, args),
   "supi:harness": (platform, ctx, args) => { void handleHarness(platform, ctx, args); },
   "supi:memory": (platform, ctx, args) => handleMemory(platform, ctx, args),
+  "runbook": (platform, ctx, args) => handleRunbook(platform, ctx, args),
 };
 
-let pendingTags: string[] = [];
-
 function getInstalledVersion(platform: Platform): string | null {
   const pkgPath = platform.paths.agent("extensions", "supipowers", "package.json");
   if (!existsSync(pkgPath)) return null;
@@ -99,7 +92,6 @@ export function bootstrap(platform: Platform): void {
   registerUpdateCommand(platform);
   registerFixPrCommand(platform);
   registerDoctorCommand(platform);
-  registerMcpCommand(platform);
   registerModelCommand(platform);
   registerContextCommand(platform);
   registerOptimizeContextCommand(platform);
@@ -111,6 +103,7 @@ export function bootstrap(platform: Platform): void {
   registerUltraplanCommand(platform);
   registerHarnessCommand(platform);
   registerMemoryCommand(platform);
+  registerRunbookCommand(platform);
 
 
   registerUltraPlanRuntimeTools(platform);
@@ -131,17 +124,6 @@ export function bootstrap(platform: Platform): void {
   // message submission, so no chat message appears and no "Working..." indicator
   platform.on("input", (event, ctx) => {
     const text = event.text.trim();
-
-    // Scan for $tags
-    const registry = loadMcpRegistry(platform.paths, ctx.cwd);
-    const registeredNames = new Set(Object.keys(registry.servers));
-    if (registeredNames.size > 0) {
-      const tags = parseTags(event.text, registeredNames);
-      if (tags.length > 0) {
-        pendingTags = tags;
-      }
-    }
-
     if (!text.startsWith("/")) return;
 
     const spaceIndex = text.indexOf(" ");
@@ -157,14 +139,7 @@ export function bootstrap(platform: Platform): void {
 
   // Context-mode integration
   const config = loadConfig(platform.paths, process.cwd());
-  registerActiveToolController(platform, config, {
-    loadMcpRegistryForCwd: (cwd: string) => loadMcpRegistry(platform.paths, cwd),
-    consumePendingTags: () => {
-      const tags = pendingTags;
-      pendingTags = [];
-      return tags;
-    },
-  });
+  registerActiveToolController(platform, config);
   registerContextModeHooks(platform, config);
   registerMempalaceTool(platform, config);
   registerMempalaceHooks(platform, config);
@@ -174,9 +149,9 @@ export function bootstrap(platform: Platform): void {
   registerPlanningSystemPromptHook(platform);
   registerUiDesignSystemPromptHook(platform);
 
-  // Register harness anti-slop hooks (gated by per-repo marker file at session start).
-  // Idempotent — safe to call once per process. The hooks themselves no-op on every
-  // event when the marker is missing, so other repos see no behavior change.
+  // Register harness anti-slop hooks only for repos with a harness marker at extension boot.
+  // Registered handlers also check the marker per event, so removing the marker disables
+  // an already-started process without affecting other repos.
   registerHarnessHooks(platform);
 
 
@@ -196,23 +171,6 @@ export function bootstrap(platform: Platform): void {
     // OMP's StatusLine never clears hook statuses on /new, so extensions must do it.
     ctx.ui?.setStatus?.("supi-model", undefined);
 
-    // MCP: always register mcpc_manager tool (agent needs it even with zero servers)
-    if (platform.registerTool) {
-      registerMcpcManagerTool(platform, ctx);
-    }
-
-    // MCP server initialization (only if servers configured)
-    const mcpRegistry = loadMcpRegistry(platform.paths, ctx.cwd);
-    if (Object.keys(mcpRegistry.servers).length > 0) {
-      const mcpClient = new McpcClient((cmd, args, opts) => platform.exec(cmd, args, opts));
-      const installed = await mcpClient.checkInstalled();
-      if (!installed.installed) {
-        ctx.ui.notify("mcpc not installed — MCP servers won't connect. Run /supi:upgrade to install.", "warning");
-      } else {
-        await initializeMcpServers(mcpRegistry, mcpClient);
-      }
-    }
-
     // Check for updates in the background
     const currentVersion = getInstalledVersion(platform);
     if (!currentVersion) return;
@@ -234,90 +192,7 @@ export function bootstrap(platform: Platform): void {
   });
 
   // Session shutdown
-  platform.on("session_shutdown", async (_event, ctx) => {
+  platform.on("session_shutdown", async () => {
     await stopActiveUiDesignSession();
-
-    const mcpConfig = loadConfig(platform.paths, ctx.cwd ?? process.cwd());
-    if (!mcpConfig.mcp?.closeSessionsOnExit) return;
-
-    const registry = loadMcpRegistry(platform.paths, ctx.cwd ?? process.cwd());
-    const mcpClient = new McpcClient((cmd, args, opts) => platform.exec(cmd, args, opts));
-    const names = Object.keys(registry.servers).filter((n) => registry.servers[n].enabled);
-    await shutdownMcpServers(names, mcpClient, true);
-  });
-}
-
-function registerMcpcManagerTool(platform: Platform, ctx: any): void {
-  platform.registerTool!({
-    name: "mcpc_manager",
-    label: "MCP Server Manager",
-    description: "Add, remove, enable, disable, or refresh MCP servers managed by supipowers. Use this when the user asks to install, set up, or manage MCP servers.",
-    promptSnippet: "mcpc_manager — manage MCP servers (add, remove, enable, disable, refresh, login, logout, list, info)",
-    promptGuidelines: [
-      "Use when the user asks to install, add, or set up an MCP server",
-      "Use when the user asks to remove, disable, or manage an MCP server",
-      "Do NOT use for calling MCP tools — use the mcpc_<name> gateway tools instead",
-    ],
-    parameters: {
-      type: "object",
-      properties: {
-        action: { type: "string", enum: ["add", "remove", "enable", "disable", "refresh", "login", "logout", "set-activation", "set-taggable", "list", "info"], description: "Action to perform" },
-        name: { type: "string", description: "Server name (required for all except list/refresh-all)" },
-        url: { type: "string", description: "Server URL (required for add)" },
-        transport: { type: "string", enum: ["http", "stdio"], description: "Transport type" },
-        docsUrl: { type: "string", description: "Documentation URL for richer README generation" },
-        activation: { type: "string", enum: ["always", "contextual", "disabled"], description: "Activation mode" },
-        taggable: { type: "boolean", description: "Whether $name tag activates this server" },
-      },
-      required: ["action"],
-    },
-    async execute(_toolCallId: string, params: any, _signal: any, _onUpdate: any, toolCtx: any) {
-      // First validate via routeManagerAction
-      const result = await executeManagerAction(params, {
-        hasUI: toolCtx.hasUI ?? true,
-        ui: toolCtx.ui ?? {},
-        cwd: toolCtx.cwd ?? ctx.cwd,
-      }, {
-        addServer: () => {},
-        removeServer: () => {},
-        updateServer: () => {},
-      });
-
-      if (result.error) {
-        throw new Error(result.content[0]?.text ?? "Manager action failed");
-      }
-
-      // For actual operations, delegate to handleMcpCli
-      const cliArgs = buildCliArgsFromParams(params);
-      await handleMcpCli(platform, {
-        cwd: toolCtx.cwd ?? ctx.cwd,
-        hasUI: toolCtx.hasUI ?? true,
-        ui: {
-          notify: (msg: string) => {
-            // Collect notifications — they'll be in the tool result
-          },
-          ...toolCtx.ui,
-        },
-      }, cliArgs);
-
-      return {
-        content: result.content,
-        details: { action: params.action, name: params.name },
-      };
-    },
   });
 }
-
-function buildCliArgsFromParams(params: any): ReturnType<typeof parseCliArgs> {
-  return {
-    subcommand: params.action === "set-activation" ? "activation"
-      : params.action === "set-taggable" ? "tag"
-      : params.action,
-    name: params.name,
-    url: params.url,
-    transport: params.transport,
-    docsUrl: params.docsUrl,
-    activation: params.activation,
-    taggable: params.taggable,
-  };
-}

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"),
   };
 }