supipowers 2.1.0 → 2.2.1

package/src/context/runbook-extension-template.ts

@@ -0,0 +1,193 @@
+export const RUNBOOK_EXTENSION_NAME = "supipowers-runbook";
+export const RUNBOOK_EXTENSION_PATH = ".omp/extensions/supipowers-runbook.ts";
+
+export const RUNBOOK_EXTENSION_SOURCE = `import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { basename, extname, join } from "node:path";
+
+type RuleBucket = "ttsr" | "always" | "rulebook" | "inactive";
+
+interface RuleInfo {
+  name: string;
+  description: string | null;
+  condition: string[];
+  triggers: string[];
+  scope: string[];
+  alwaysApply: boolean;
+  source: string;
+  bucket: RuleBucket;
+}
+
+function decodeScalar(raw: string): string {
+  const value = raw.trim();
+  if (value.length === 0) return "";
+  if (value.startsWith('"')) {
+    try {
+      return JSON.parse(value);
+    } catch {
+      return value.slice(1, value.endsWith('"') ? -1 : undefined);
+    }
+  }
+  if (value.startsWith("'") && value.endsWith("'")) return value.slice(1, -1);
+  return value;
+}
+
+function parseFrontmatter(text: string): { metadata: Record<string, string | string[]>; body: string } {
+  if (!text.startsWith("---\n")) return { metadata: {}, body: text.trim() };
+  const close = text.indexOf("\n---", 4);
+  if (close === -1) return { metadata: {}, body: text.trim() };
+  const raw = text.slice(4, close);
+  const bodyStart = text.indexOf("\n", close + 4);
+  const body = bodyStart === -1 ? "" : text.slice(bodyStart + 1).trim();
+  const metadata: Record<string, string | string[]> = {};
+  let currentKey: string | null = null;
+
+  for (const line of raw.split(/\r?\n/)) {
+    const keyMatch = /^(\\w+):\\s*(.*)$/.exec(line);
+    if (keyMatch) {
+      currentKey = keyMatch[1];
+      const value = keyMatch[2].trim();
+      metadata[currentKey] = value.length === 0 ? [] : decodeScalar(value);
+      continue;
+    }
+    const listMatch = /^\\s*-\\s*(.*)$/.exec(line);
+    if (listMatch && currentKey) {
+      const existing = metadata[currentKey];
+      const values = Array.isArray(existing) ? existing : existing ? [existing] : [];
+      values.push(decodeScalar(listMatch[1]));
+      metadata[currentKey] = values;
+    }
+  }
+
+  return { metadata, body };
+}
+
+function asList(value: string | string[] | undefined): string[] {
+  if (Array.isArray(value)) return value.filter(Boolean);
+  if (!value) return [];
+  return value.split(",").map((entry) => entry.trim()).filter(Boolean);
+}
+
+function nameFromPath(filePath: string): string {
+  const base = basename(filePath);
+  const ext = extname(base);
+  return ext ? base.slice(0, -ext.length) : base;
+}
+
+function bucket(rule: Pick<RuleInfo, "condition" | "alwaysApply" | "description">): RuleBucket {
+  if (rule.condition.length > 0) return "ttsr";
+  if (rule.alwaysApply) return "always";
+  if (rule.description) return "rulebook";
+  return "inactive";
+}
+
+function discoverRules(cwd: string): RuleInfo[] {
+  const dir = join(cwd, ".omp", "rules");
+  if (!existsSync(dir)) return [];
+  const rules: RuleInfo[] = [];
+  for (const entry of readdirSync(dir).sort()) {
+    const filePath = join(dir, entry);
+    if (![".md", ".mdc"].includes(extname(filePath))) continue;
+    try {
+      if (!statSync(filePath).isFile()) continue;
+      const parsed = parseFrontmatter(readFileSync(filePath, "utf8"));
+      const info: RuleInfo = {
+        name: nameFromPath(filePath),
+        description: typeof parsed.metadata.description === "string" ? parsed.metadata.description : null,
+        condition: asList(parsed.metadata.condition),
+        triggers: asList(parsed.metadata.triggers ?? parsed.metadata.triggerDescription),
+        scope: asList(parsed.metadata.scope),
+        alwaysApply: parsed.metadata.alwaysApply === "true",
+        source: filePath,
+        bucket: "inactive",
+      };
+      info.bucket = bucket(info);
+      rules.push(info);
+    } catch {
+      // Keep runbook display best-effort; unreadable rules should not break the command.
+    }
+  }
+  return rules;
+}
+
+function describeScope(rule: RuleInfo): string {
+  if (rule.scope.length === 0) return "assistant prose and tool-call text";
+  const labels = rule.scope.map((scope) => {
+    const normalized = scope.toLowerCase();
+    if (normalized === "text") return "assistant prose";
+    if (normalized === "thinking") return "assistant thinking";
+    if (normalized === "tool" || normalized === "toolcall") return "all tool-call text";
+    return "tool scope " + scope;
+  });
+  return labels.join(", ") + " only";
+}
+
+function formatRule(rule: RuleInfo): string[] {
+  const lines = ["  " + rule.name];
+  if (rule.description) lines.push("    Description: " + rule.description);
+  if (rule.bucket === "ttsr") {
+    lines.push("    Applies: when assistant output matches the trigger phrase(s)");
+    if (rule.triggers.length > 0) {
+      lines.push("    Triggers: " + rule.triggers.join(", "));
+    } else {
+      lines.push("    Triggers: exact regex only; add triggers: frontmatter for readability");
+      for (const condition of rule.condition) lines.push("      - " + condition);
+    }
+    lines.push("    Scope: " + describeScope(rule));
+  } else if (rule.bucket === "always") {
+    lines.push("    Applies: always injected at session start");
+  } else if (rule.bucket === "rulebook") {
+    lines.push("    Applies: on demand via rule://" + rule.name);
+  } else {
+    lines.push("    Applies: inactive in prompt surfaces");
+  }
+  return lines;
+}
+
+function formatRules(cwd: string, onlyTtsr: boolean): string {
+  const rules = discoverRules(cwd).filter((rule) => !onlyTtsr || rule.bucket === "ttsr");
+  const lines = [onlyTtsr ? "/runbook rules ttsr" : "/runbook rules", "", "Rules: " + rules.length, ""];
+  if (rules.length === 0) return [...lines, "  none"].join("\\n");
+  for (const rule of rules.sort((a, b) => a.name.localeCompare(b.name))) {
+    lines.push(...formatRule(rule), "");
+  }
+  return lines.join("\\n").trimEnd();
+}
+
+function formatCommands(api: any): string {
+  const commands = typeof api.getCommands === "function" ? api.getCommands() : [];
+  const lines = ["/runbook commands", "", "Registered slash commands: " + commands.length, ""];
+  for (const command of [...commands].sort((a: any, b: any) => String(a.name).localeCompare(String(b.name)))) {
+    lines.push("  /" + command.name, "    " + (command.description ?? "No description"));
+  }
+  return lines.join("\\n");
+}
+
+function buildReport(api: any, cwd: string, args?: string): string {
+  const tokens = (args ?? "").trim().split(/\\s+/).filter(Boolean).map((token) => token.toLowerCase());
+  if (tokens[0] === "commands" || tokens[1] === "commands") return formatCommands(api);
+  if (tokens[0] === "ttsr" || tokens[1] === "ttsr") return formatRules(cwd, true);
+  return formatRules(cwd, false);
+}
+
+export default function supipowersRunbook(api: any): void {
+  const handle = (args: string | undefined, ctx: any): void => {
+    if (!ctx?.hasUI || !ctx.ui?.notify) return;
+    ctx.ui.notify(buildReport(api, ctx.cwd ?? process.cwd(), args), "info");
+  };
+
+  api.registerCommand?.("runbook", {
+    description: "Show project rules, TTSR triggers, and slash commands without an LLM turn",
+    async handler(args: string | undefined, ctx: any): Promise<void> {
+      handle(args, ctx);
+    },
+  });
+
+  api.on?.("input", (event: any, ctx: any) => {
+    const text = String(event?.text ?? "").trim();
+    if (!text.startsWith("/runbook")) return;
+    const args = text.length > "/runbook".length ? text.slice("/runbook".length).trim() : undefined;
+    handle(args, ctx);
+    return { handled: true };
+  });
+}
+`;

package/src/context/startup-check.ts

@@ -1,5 +1,5 @@
 import type { ParsedSkill, PromptSection } from "./analyzer.js";
-import { parseManagedRule } from "./rule-renderer.js";
+import { MANAGED_COMMAND_HEADER, parseManagedCommand, parseManagedExtension, parseManagedRule } from "./rule-renderer.js";
 import {
   hashOptimizationSource,
   type ManualOptimizationAction,
@@ -16,9 +16,32 @@ export interface StartupOptimizerManifestRule {
   slug: string;
   sourceBytes: number;
   condition?: string;
+  triggers?: string;
+  scope?: string;
   description?: string;
 }
 
+export interface StartupOptimizerManifestCommand {
+  path: string;
+  sourceId: string;
+  sourceName: string;
+  sourceHash: string;
+  slug: string;
+  commandName: string;
+  sourceBytes: number;
+  description?: string;
+}
+
+export interface StartupOptimizerManifestExtension {
+  path: string;
+  sourceId: string;
+  sourceName: string;
+  sourceHash: string;
+  slug: string;
+  extensionName: string;
+  sourceBytes: number;
+}
+
 export interface StartupOptimizerManifest {
   version: 1;
   targetBytes: number;
@@ -27,6 +50,8 @@ export interface StartupOptimizerManifest {
   estimatedAfterBytes: number;
   estimatedSavedBytes: number;
   rules: StartupOptimizerManifestRule[];
+  commands: StartupOptimizerManifestCommand[];
+  extensions: StartupOptimizerManifestExtension[];
   tokenignore: {
     path: string;
     entries: string[];
@@ -46,6 +71,16 @@ export type StartupCheckReason =
   | "rule-drift"
   | "rule-body-drift"
   | "tokenignore-drift"
+  | "missing-command"
+  | "unmanaged-command"
+  | "malformed-command"
+  | "command-drift"
+  | "command-body-drift"
+  | "missing-extension"
+  | "unmanaged-extension"
+  | "malformed-extension"
+  | "extension-drift"
+  | "extension-body-drift"
   | "still-loaded-source"
   | "unresolved-manual-action"
   | "prompt-over-target"
@@ -64,6 +99,8 @@ export interface StartupCheckInput {
   manifestPath: string;
   manifestText: string | null | undefined;
   ruleFiles: Record<string, string | null | undefined>;
+  commandFiles?: Record<string, string | null | undefined>;
+  extensionFiles?: Record<string, string | null | undefined>;
   tokenignorePath: string;
   tokenignoreText: string | null | undefined;
   currentPrompt: string | null | undefined;
@@ -153,7 +190,9 @@ export function runStartupCheck(input: StartupCheckInput): StartupCheckReport {
 
     const metadata = parsed.metadata;
     const frontmatterDrift = rule.mode === "ttsr"
-      ? parsed.frontmatter.condition !== rule.condition
+      ? parsed.frontmatter.condition !== rule.condition ||
+        (typeof rule.triggers === "string" && parsed.frontmatter.triggers !== rule.triggers) ||
+        parsed.frontmatter.scope !== (rule.scope ?? "text")
       : (typeof rule.description === "string" && parsed.frontmatter.description !== rule.description);
 
     if (
@@ -187,6 +226,133 @@ export function runStartupCheck(input: StartupCheckInput): StartupCheckReport {
     }
   }
 
+
+  for (const command of manifest.commands) {
+    const text = input.commandFiles?.[command.path];
+    if (text == null) {
+      issues.push(issue("missing-command", {
+        path: command.path,
+        sourceId: command.sourceId,
+        message: `Managed command file is missing for ${command.sourceId}.`,
+        remediation: "Rerun /supi:optimize-context --apply to regenerate managed commands.",
+      }));
+      continue;
+    }
+
+    const parsed = parseManagedCommand(text);
+    if (parsed.status === "unmanaged") {
+      issues.push(issue("unmanaged-command", {
+        path: command.path,
+        sourceId: command.sourceId,
+        message: `Command file ${command.path} is not managed by supipowers.`,
+        remediation: "Move the user-authored command aside or choose a different command name before applying again.",
+      }));
+      continue;
+    }
+
+    if (parsed.status === "malformed") {
+      issues.push(issue("malformed-command", {
+        path: command.path,
+        sourceId: command.sourceId,
+        message: `Managed command ${command.path} is malformed: ${parsed.error}.`,
+        remediation: "Rerun /supi:optimize-context --apply to rewrite the managed command.",
+      }));
+      continue;
+    }
+
+    // Legacy managed commands stored supipowers metadata before command
+    // frontmatter. OMP sends that prefix as prompt text, so force a refresh.
+    const commandDrift =
+      text.startsWith(MANAGED_COMMAND_HEADER) ||
+      parsed.metadata.sourceId !== command.sourceId ||
+      parsed.metadata.sourceHash !== command.sourceHash ||
+      parsed.metadata.slug !== command.slug ||
+      parsed.metadata.commandName !== command.commandName ||
+      parsed.metadata.sourceBytes !== command.sourceBytes ||
+      (typeof command.description === "string" && parsed.frontmatter.description !== command.description);
+    if (commandDrift) {
+      issues.push(issue("command-drift", {
+        path: command.path,
+        sourceId: command.sourceId,
+        message: `Managed command ${command.path} no longer matches the startup optimizer manifest.`,
+        remediation: "Rerun /supi:optimize-context --apply to refresh managed command artifacts.",
+      }));
+      continue;
+    }
+
+    const actualBodyHash = hashOptimizationSource(parsed.body);
+    const actualBodyBytes = byteLength(parsed.body);
+    if (actualBodyHash !== command.sourceHash || actualBodyBytes !== command.sourceBytes) {
+      issues.push(issue("command-body-drift", {
+        path: command.path,
+        sourceId: command.sourceId,
+        message: `Managed command ${command.path} body has been modified (hash/size no longer matches the manifest).`,
+        remediation: "Rerun /supi:optimize-context --apply to rewrite the managed command from the current prompt source.",
+      }));
+    }
+  }
+
+  for (const extension of manifest.extensions) {
+    const text = input.extensionFiles?.[extension.path];
+    if (text == null) {
+      issues.push(issue("missing-extension", {
+        path: extension.path,
+        sourceId: extension.sourceId,
+        message: `Managed extension file is missing for ${extension.sourceId}.`,
+        remediation: "Rerun /supi:optimize-context --apply to regenerate managed extensions.",
+      }));
+      continue;
+    }
+
+    const parsed = parseManagedExtension(text);
+    if (parsed.status === "unmanaged") {
+      issues.push(issue("unmanaged-extension", {
+        path: extension.path,
+        sourceId: extension.sourceId,
+        message: `Extension file ${extension.path} is not managed by supipowers.`,
+        remediation: "Move the user-authored extension aside or choose a different extension name before applying again.",
+      }));
+      continue;
+    }
+
+    if (parsed.status === "malformed") {
+      issues.push(issue("malformed-extension", {
+        path: extension.path,
+        sourceId: extension.sourceId,
+        message: `Managed extension ${extension.path} is malformed: ${parsed.error}.`,
+        remediation: "Rerun /supi:optimize-context --apply to rewrite the managed extension.",
+      }));
+      continue;
+    }
+
+    const extensionDrift =
+      parsed.metadata.sourceId !== extension.sourceId ||
+      parsed.metadata.sourceHash !== extension.sourceHash ||
+      parsed.metadata.slug !== extension.slug ||
+      parsed.metadata.extensionName !== extension.extensionName ||
+      parsed.metadata.sourceBytes !== extension.sourceBytes;
+    if (extensionDrift) {
+      issues.push(issue("extension-drift", {
+        path: extension.path,
+        sourceId: extension.sourceId,
+        message: `Managed extension ${extension.path} no longer matches the startup optimizer manifest.`,
+        remediation: "Rerun /supi:optimize-context --apply to refresh managed extension artifacts.",
+      }));
+      continue;
+    }
+
+    const actualBodyHash = hashOptimizationSource(parsed.body);
+    const actualBodyBytes = byteLength(parsed.body);
+    if (actualBodyHash !== extension.sourceHash || actualBodyBytes !== extension.sourceBytes) {
+      issues.push(issue("extension-body-drift", {
+        path: extension.path,
+        sourceId: extension.sourceId,
+        message: `Managed extension ${extension.path} body has been modified (hash/size no longer matches the manifest).`,
+        remediation: "Rerun /supi:optimize-context --apply to rewrite the managed extension from the current optimizer template.",
+      }));
+    }
+  }
+
   const tokenignore = parseManagedTokenignore(input.tokenignoreText);
   if (
     tokenignore.status !== "managed" ||
@@ -213,6 +379,10 @@ export function runStartupCheck(input: StartupCheckInput): StartupCheckReport {
     if (rule.sourceId.startsWith("skill:")) skillSourceIdsToVerify.add(rule.sourceId);
     else if (rule.sourceId.startsWith("section:")) sectionSourceIdsToVerify.add(rule.sourceId);
   }
+  for (const command of manifest.commands) {
+    if (command.sourceId.startsWith("skill:")) skillSourceIdsToVerify.add(command.sourceId);
+    else if (command.sourceId.startsWith("section:")) sectionSourceIdsToVerify.add(command.sourceId);
+  }
   for (const action of manifest.manualActions) {
     if (action.kind !== "manual-disable") continue;
     if (action.sourceId.startsWith("skill:")) skillSourceIdsToVerify.add(action.sourceId);
@@ -310,6 +480,29 @@ export function parseStartupOptimizerManifest(
     rules.push(candidate as unknown as StartupOptimizerManifestRule);
   }
 
+  const commands: StartupOptimizerManifestCommand[] = [];
+  const rawCommands = Array.isArray((parsed as any).commands) ? (parsed as any).commands : [];
+  for (const candidate of rawCommands) {
+    if (!isRecord(candidate)) return "Startup optimizer manifest has invalid command entry.";
+    for (const key of ["path", "sourceId", "sourceName", "sourceHash", "slug", "commandName"] as const) {
+      if (typeof candidate[key] !== "string") return `Startup optimizer manifest command is missing ${key}.`;
+    }
+    if (!isFiniteNumber(candidate.sourceBytes)) return "Startup optimizer manifest command is missing sourceBytes.";
+    commands.push(candidate as unknown as StartupOptimizerManifestCommand);
+  }
+
+  const extensions: StartupOptimizerManifestExtension[] = [];
+  const rawExtensions = Array.isArray((parsed as any).extensions) ? (parsed as any).extensions : [];
+  for (const candidate of rawExtensions) {
+    if (!isRecord(candidate)) return "Startup optimizer manifest has invalid extension entry.";
+    for (const key of ["path", "sourceId", "sourceName", "sourceHash", "slug", "extensionName"] as const) {
+      if (typeof candidate[key] !== "string") return `Startup optimizer manifest extension is missing ${key}.`;
+    }
+    if (!isFiniteNumber(candidate.sourceBytes)) return "Startup optimizer manifest extension is missing sourceBytes.";
+    extensions.push(candidate as unknown as StartupOptimizerManifestExtension);
+  }
+
+
   if (typeof parsed.tokenignore.path !== "string") return "Startup optimizer manifest tokenignore is missing path.";
   if (!Array.isArray(parsed.tokenignore.entries) || !parsed.tokenignore.entries.every((entry) => typeof entry === "string")) {
     return "Startup optimizer manifest tokenignore has invalid entries.";
@@ -324,6 +517,8 @@ export function parseStartupOptimizerManifest(
     estimatedAfterBytes: parsed.estimatedAfterBytes,
     estimatedSavedBytes: parsed.estimatedSavedBytes,
     rules,
+    commands,
+    extensions,
     tokenignore: {
       path: parsed.tokenignore.path,
       entries: parsed.tokenignore.entries,

package/src/context/startup-optimizer.ts

@@ -1,5 +1,6 @@
 import { createHash } from "node:crypto";
 import type { ParsedSkill, PromptSection } from "./analyzer.js";
+import { RUNBOOK_EXTENSION_NAME, RUNBOOK_EXTENSION_PATH, RUNBOOK_EXTENSION_SOURCE } from "./runbook-extension-template.js";
 import type { TechStack } from "./optimizer.js";
 
 export const STARTUP_OPTIMIZER_MANIFEST_VERSION = 1;
@@ -33,6 +34,35 @@ export interface WriteRuleAction {
   sourceContent: string;
   condition?: string;
   description?: string;
+  triggers?: string;
+  scope?: string;
+}
+
+export interface WriteCommandAction {
+  kind: "write-command";
+  sourceId: string;
+  sourceName: string;
+  sourceHash: string;
+  slug: string;
+  commandName: string;
+  targetPath: string;
+  sourceBytes: number;
+  estimatedSavedBytes: number;
+  sourceContent: string;
+  description?: string;
+}
+
+export interface WriteExtensionAction {
+  kind: "write-extension";
+  sourceId: string;
+  sourceName: string;
+  sourceHash: string;
+  slug: string;
+  extensionName: string;
+  targetPath: string;
+  sourceBytes: number;
+  estimatedSavedBytes: number;
+  sourceContent: string;
 }
 
 export type ManualDisableReason = "source-still-loaded" | "tech-stack-irrelevant";
@@ -58,7 +88,7 @@ export interface ManualAgentsSplitAction {
 }
 
 export type ManualOptimizationAction = ManualDisableAction | ManualAgentsSplitAction;
-export type OptimizationAction = WriteRuleAction | ManualOptimizationAction;
+export type OptimizationAction = WriteRuleAction | WriteCommandAction | WriteExtensionAction | ManualOptimizationAction;
 
 export interface OptimizationWarning {
   code: string;
@@ -91,27 +121,44 @@ export interface BuildOptimizationPlanInput {
   techStack: TechStack;
 }
 
+interface TtsrRuleOptions {
+  condition: string;
+  triggers?: string;
+  scope?: string;
+}
+
+
 interface BehaviorSkillSpec {
   mode: "ttsr";
   condition: string;
+  triggers: string;
+  scope: string;
 }
 
 const BEHAVIOR_SKILLS: Record<string, BehaviorSkillSpec> = {
   debugging: {
     mode: "ttsr",
     condition: String.raw`\b(?:debug(?:ging)?|root\s+cause|investigate|repro(?:duce|duction)?|failing\s+test)\b`,
+    triggers: "debugging, root cause, investigate, reproduce, failing test",
+    scope: "text",
   },
   tdd: {
     mode: "ttsr",
     condition: String.raw`\b(?:tdd|test\s+first|failing\s+test\s+first|red[-\s]+green[-\s]+refactor)\b`,
+    triggers: "TDD, test first, failing test first, red-green-refactor",
+    scope: "text",
   },
   verification: {
     mode: "ttsr",
     condition: String.raw`\b(?:verify|verification|evidence|prove|proof|run\s+(?:the\s+)?(?:focused\s+)?tests?)\b`,
+    triggers: "verify, verification, evidence, proof, run focused tests",
+    scope: "text",
   },
   "receiving-code-review": {
     mode: "ttsr",
     condition: String.raw`\b(?:pr\s+feedback|code\s+review\s+comments?|reviewer\s+feedback|review\s+comments?)\b`,
+    triggers: "PR feedback, code review comments, reviewer feedback",
+    scope: "text",
   },
 };
 
@@ -130,10 +177,40 @@ const TECH_STACK_SKILLS: Record<string, { anyOf: Array<keyof TechStack>; values:
   },
 };
 
+const WORKFLOW_COMMAND_SKILLS = new Set([
+  "rewrite-page-copy",
+  "e2e-test-orchestrator",
+  "design-refiner",
+  "workflow-extractor",
+  "engaging-writing",
+  "brand-namer",
+  "brand-forge",
+  "product-linear-issues",
+  "skill-auditor",
+  "caveman",
+  "caveman-compress",
+  "security-threat-model",
+  "brand-migrate",
+  "audit",
+  "setup-tyndale",
+  "setup-tyndale-local",
+  "writing-commands",
+  "playwright",
+  "ui-design",
+  "quick-setup",
+  "planning",
+  "fix-pr",
+  "create-readme",
+  "translate-book",
+]);
+
+
 const ACTION_KIND_ORDER: Record<OptimizationAction["kind"], number> = {
   "write-rule": 0,
-  "manual-disable": 1,
-  "manual-agents-split": 2,
+  "write-command": 1,
+  "write-extension": 2,
+  "manual-disable": 3,
+  "manual-agents-split": 4,
 };
 
 export function hashOptimizationSource(content: string): string {
@@ -162,12 +239,24 @@ export function buildOptimizationPlan(input: BuildOptimizationPlanInput): Optimi
   const actions: OptimizationAction[] = [];
   const warnings: OptimizationWarning[] = [];
 
+  actions.push(buildRunbookExtensionAction());
+
   for (const source of sources) {
     if (source.sourceType === "skill") {
       const canonicalName = source.sourceName.toLowerCase();
       const behavior = BEHAVIOR_SKILLS[canonicalName];
       if (behavior) {
-        actions.push(buildWriteRuleAction(source, behavior.mode, behavior.condition));
+        actions.push(buildWriteRuleAction(source, behavior.mode, {
+          condition: behavior.condition,
+          triggers: behavior.triggers,
+          scope: behavior.scope,
+        }));
+        actions.push(buildManualDisableAction(source, "source-still-loaded"));
+        continue;
+      }
+
+      if (WORKFLOW_COMMAND_SKILLS.has(canonicalName)) {
+        actions.push(buildWriteCommandAction(source));
         actions.push(buildManualDisableAction(source, "source-still-loaded"));
         continue;
       }
@@ -202,12 +291,12 @@ export function buildOptimizationPlan(input: BuildOptimizationPlanInput): Optimi
   const beforeBytes = byteLength(input.prompt);
 
   // Sources whose content the user is expected to actually remove from the
-  // startup prompt: write-rule companions and tech-stack manual-disable
-  // actions. Deduplicated by sourceId because a write-rule action is paired
-  // with a `source-still-loaded` manual-disable for the same source.
+  // startup prompt: write-rule companions, write-command companions, and
+  // manual-disable actions. Deduplicated by sourceId because generated artifacts
+  // are paired with `source-still-loaded` manual-disable records.
   const removedSourceIds = new Set<string>();
   for (const action of actions) {
-    if (action.kind === "write-rule" || action.kind === "manual-disable") {
+    if (action.kind === "write-rule" || action.kind === "write-command" || action.kind === "manual-disable") {
       removedSourceIds.add(action.sourceId);
     }
   }
@@ -289,7 +378,7 @@ function canonicalSourceContent(content: string): string {
 function buildWriteRuleAction(
   source: OptimizationSource,
   mode: RuleMode,
-  condition?: string,
+  ttsr?: TtsrRuleOptions,
 ): WriteRuleAction {
   return {
     kind: "write-rule",
@@ -302,7 +391,41 @@ function buildWriteRuleAction(
     sourceBytes: source.bytes,
     estimatedSavedBytes: source.bytes,
     sourceContent: source.content,
-    ...(condition ? { condition } : {}),
+    ...(ttsr ? { condition: ttsr.condition, triggers: ttsr.triggers, scope: ttsr.scope } : {}),
+  };
+}
+
+function buildWriteCommandAction(source: OptimizationSource): WriteCommandAction {
+  const commandName = slugifyOptimizationSource(source.sourceName);
+  return {
+    kind: "write-command",
+    sourceId: source.sourceId,
+    sourceName: source.sourceName,
+    sourceHash: source.sourceHash,
+    slug: source.slug,
+    commandName,
+    targetPath: `.omp/commands/${commandName}.md`,
+    sourceBytes: source.bytes,
+    estimatedSavedBytes: source.bytes,
+    sourceContent: source.content,
+    description: `Run the ${source.sourceName} workflow on demand.`,
+  };
+}
+
+function buildRunbookExtensionAction(): WriteExtensionAction {
+  const sourceContent = canonicalSourceContent(RUNBOOK_EXTENSION_SOURCE);
+  const sourceBytes = byteLength(sourceContent);
+  return {
+    kind: "write-extension",
+    sourceId: "extension:runbook",
+    sourceName: RUNBOOK_EXTENSION_NAME,
+    sourceHash: hashOptimizationSource(sourceContent),
+    slug: "extension-runbook",
+    extensionName: RUNBOOK_EXTENSION_NAME,
+    targetPath: RUNBOOK_EXTENSION_PATH,
+    sourceBytes,
+    estimatedSavedBytes: 0,
+    sourceContent,
   };
 }