@useorgx/wizard 0.1.10 → 0.1.12

package/dist/cli.js

@@ -2,6 +2,7 @@
 
 // src/cli.ts
 import * as clack from "@clack/prompts";
+import { spawnSync as spawnSync3 } from "child_process";
 import { hostname } from "os";
 import { Command } from "commander";
 import pc3 from "picocolors";
@@ -54,6 +55,7 @@ var XDG_CONFIG_HOME = process.env.XDG_CONFIG_HOME?.trim() || join(HOME, ".config
 var ORGX_WIZARD_CONFIG_HOME = process.env.ORGX_WIZARD_CONFIG_HOME?.trim() || join(XDG_CONFIG_HOME, "useorgx", "wizard");
 var ORGX_WIZARD_AUTH_PATH = join(ORGX_WIZARD_CONFIG_HOME, "auth.json");
 var ORGX_WIZARD_STATE_PATH = join(ORGX_WIZARD_CONFIG_HOME, "state.json");
+var ORGX_SKILL_EXTENSIONS_DIR = join(ORGX_WIZARD_CONFIG_HOME, "skill-extensions");
 var ORGX_WIZARD_KEYTAR_SERVICE = "@useorgx/wizard";
 var ORGX_WIZARD_KEYTAR_ACCOUNT = "orgx-api-key";
 function normalizeOrgxApiBaseUrl(baseUrl) {
@@ -80,6 +82,8 @@ var CLAUDE_ORGX_SKILL_DIR = join(CLAUDE_SKILLS_DIR, "orgx");
 var CLAUDE_ORGX_SKILL_PATH = join(CLAUDE_ORGX_SKILL_DIR, "SKILL.md");
 var CURSOR_RULES_DIR = join(CURSOR_DIR, "rules");
 var CURSOR_ORGX_RULE_PATH = join(CURSOR_RULES_DIR, "orgx.md");
+var CURSOR_PLUGINS_DIR = join(CURSOR_DIR, "plugins", "local");
+var CURSOR_ORGX_PLUGIN_DIR = join(CURSOR_PLUGINS_DIR, "cursor-plugin");
 var CODEX_PLUGINS_DIR = join(CODEX_DIR, "plugins");
 var CODEX_ORGX_PLUGIN_DIR = join(CODEX_PLUGINS_DIR, "orgx-codex-plugin");
 var CODEX_MARKETPLACE_DIR = join(AGENTS_DIR, "plugins");
@@ -978,6 +982,39 @@ function parseAgentRoster(value) {
     ...isNonEmptyString2(record.workspaceName) ? { workspaceName: record.workspaceName.trim() } : {}
   };
 }
+function parseSkillFileRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return void 0;
+  }
+  const record = value;
+  if (!isNonEmptyString2(record.path) || !isNonEmptyString2(record.skillId) || !isNonEmptyString2(record.contentSha256) || !isNonEmptyString2(record.updatedAt)) {
+    return void 0;
+  }
+  return {
+    contentSha256: record.contentSha256.trim(),
+    path: record.path.trim(),
+    skillId: record.skillId.trim(),
+    updatedAt: record.updatedAt.trim(),
+    ...isNonEmptyString2(record.coreSha256) ? { coreSha256: record.coreSha256.trim() } : {}
+  };
+}
+function parseSkillFiles(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return void 0;
+  }
+  const record = value;
+  if (!isNonEmptyString2(record.updatedAt) || !Array.isArray(record.files)) {
+    return void 0;
+  }
+  const files = record.files.map((entry) => parseSkillFileRecord(entry)).filter((entry) => Boolean(entry));
+  if (files.length === 0) {
+    return void 0;
+  }
+  return {
+    files,
+    updatedAt: record.updatedAt.trim()
+  };
+}
 function createWizardState(now = (/* @__PURE__ */ new Date()).toISOString()) {
   return {
     installationId: `wizard-${randomUUID()}`,
@@ -990,6 +1027,7 @@ function sanitizeWizardStateRecord(record) {
   const agentRoster = parseAgentRoster(record.agentRoster);
   const demoInitiative = parseDemoInitiative(record.demoInitiative);
   const onboardingTask = parseOnboardingTask(record.onboardingTask);
+  const skillFiles = parseSkillFiles(record.skillFiles);
   return {
     installationId: record.installationId.trim(),
     createdAt: record.createdAt.trim(),
@@ -997,7 +1035,8 @@ function sanitizeWizardStateRecord(record) {
     ...continuity ? { continuity } : {},
     ...agentRoster ? { agentRoster } : {},
     ...demoInitiative ? { demoInitiative } : {},
-    ...onboardingTask ? { onboardingTask } : {}
+    ...onboardingTask ? { onboardingTask } : {},
+    ...skillFiles ? { skillFiles } : {}
   };
 }
 function readWizardState(statePath = ORGX_WIZARD_STATE_PATH) {
@@ -1018,6 +1057,8 @@ function readWizardState(statePath = ORGX_WIZARD_STATE_PATH) {
   if (demoInitiative !== void 0) state.demoInitiative = demoInitiative;
   const onboardingTask = parseOnboardingTask(parsed.onboardingTask);
   if (onboardingTask !== void 0) state.onboardingTask = onboardingTask;
+  const skillFiles = parseSkillFiles(parsed.skillFiles);
+  if (skillFiles !== void 0) state.skillFiles = skillFiles;
   return state;
 }
 function writeWizardState(value, statePath = ORGX_WIZARD_STATE_PATH) {
@@ -3005,7 +3046,9 @@ async function ensureOnboardingTask(workspace, options = {}) {
 }
 
 // src/lib/skills.ts
-import { join as join2 } from "path";
+import { createHash } from "crypto";
+import { existsSync as existsSync3, readdirSync } from "fs";
+import { basename, join as join2 } from "path";
 var DEFAULT_ORGX_SKILL_PACKS = [
   "morning-briefing",
   "initiative-kickoff",
@@ -3017,6 +3060,9 @@ var EXCLUDED_PACK_DIRS = /* @__PURE__ */ new Set([".github", "scripts"]);
 var ORGX_SKILLS_OWNER = "useorgx";
 var ORGX_SKILLS_REPO = "skills";
 var ORGX_SKILLS_REF = "main";
+var SKILL_EXTENSION_SCOPES = ["user", "workspace", "project"];
+var COMPOSED_SKILL_MARKER = "ORGX SKILL COMPOSED v1";
+var EXTENSION_FRONTMATTER_DELIMITER = "---";
 var CURSOR_RULES_CONTENT = `# OrgX Rules
 
 - Prefer \`workspace_id\` on OrgX tool calls. \`command_center_id\` is a deprecated alias and should only be used for backwards compatibility. If both are present, they must match.
@@ -3072,6 +3118,219 @@ Install and use these packs alongside this base skill:
 4. When you scaffold, decide up front whether \`continue_on_error\` is acceptable.
 5. Carry \`_context\` through any widget-producing flows so the UI can render and resume correctly.
 `;
+function sha256(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+function normalizeSkillId(value) {
+  const normalized = value.trim().toLowerCase();
+  if (!/^[a-z0-9][a-z0-9._-]*$/.test(normalized)) {
+    throw new Error(
+      "Skill id must start with a letter or number and only contain letters, numbers, '.', '_' or '-'."
+    );
+  }
+  return normalized;
+}
+function normalizeSkillExtensionScope(value) {
+  const normalized = (value ?? "user").trim().toLowerCase();
+  if (!SKILL_EXTENSION_SCOPES.includes(normalized)) {
+    throw new Error("Skill extension scope must be one of: user, workspace, project.");
+  }
+  return normalized;
+}
+function defaultExtensionTitle(skillId, scope) {
+  const prefix = scope === "user" ? "Personal" : scope === "workspace" ? "Workspace" : "Project";
+  return `${prefix} ${skillId} behavior`;
+}
+function extensionFilePath(skillId, scope, extensionsDir = ORGX_SKILL_EXTENSIONS_DIR) {
+  return join2(extensionsDir, `${scope}.${skillId}.md`);
+}
+function extensionTemplate(input) {
+  const body = input.content?.trim() ? input.content.trim() : [
+    `# ${input.title}`,
+    "",
+    "- Add your custom behavior here.",
+    "- These instructions are appended after the OrgX-managed core skill when the wizard syncs skills."
+  ].join("\n");
+  return [
+    EXTENSION_FRONTMATTER_DELIMITER,
+    `skill: ${input.skillId}`,
+    `scope: ${input.scope}`,
+    "enabled: true",
+    `title: ${input.title}`,
+    EXTENSION_FRONTMATTER_DELIMITER,
+    "",
+    body,
+    ""
+  ].join("\n");
+}
+function parseFrontmatter(content) {
+  if (!content.startsWith(`${EXTENSION_FRONTMATTER_DELIMITER}
+`)) {
+    return { body: content, data: {} };
+  }
+  const closeIndex = content.indexOf(`
+${EXTENSION_FRONTMATTER_DELIMITER}
+`, 4);
+  if (closeIndex === -1) {
+    return { body: content, data: {} };
+  }
+  const raw = content.slice(4, closeIndex);
+  const body = content.slice(closeIndex + 5);
+  const data = {};
+  for (const line of raw.split("\n")) {
+    const index = line.indexOf(":");
+    if (index === -1) {
+      continue;
+    }
+    const key = line.slice(0, index).trim();
+    const value = line.slice(index + 1).trim();
+    if (key) {
+      data[key] = value;
+    }
+  }
+  return { body, data };
+}
+function serializeFrontmatter(data, body) {
+  return [
+    EXTENSION_FRONTMATTER_DELIMITER,
+    ...Object.entries(data).map(([key, value]) => `${key}: ${value}`),
+    EXTENSION_FRONTMATTER_DELIMITER,
+    "",
+    body.trimEnd(),
+    ""
+  ].join("\n");
+}
+function parseSkillExtension(path, content) {
+  const fallbackId = basename(path, ".md");
+  const fallbackParts = fallbackId.split(".");
+  const fallbackScope = normalizeSkillExtensionScope(
+    SKILL_EXTENSION_SCOPES.includes(fallbackParts[0]) ? fallbackParts.shift() : "user"
+  );
+  const fallbackSkillId = normalizeSkillId(fallbackParts.join(".") || fallbackId);
+  const parsed = parseFrontmatter(content);
+  const skillId = normalizeSkillId(parsed.data.skill || fallbackSkillId);
+  const scope = normalizeSkillExtensionScope(parsed.data.scope || fallbackScope);
+  const title = parsed.data.title?.trim() || defaultExtensionTitle(skillId, scope);
+  return {
+    content: parsed.body.trim(),
+    enabled: parsed.data.enabled?.trim().toLowerCase() !== "false",
+    id: `${scope}.${skillId}`,
+    path,
+    scope,
+    skillId,
+    title
+  };
+}
+function listSkillExtensions(options = {}) {
+  const extensionsDir = options.extensionsDir ?? ORGX_SKILL_EXTENSIONS_DIR;
+  if (!existsSync3(extensionsDir)) {
+    return [];
+  }
+  return readdirSync(extensionsDir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".md")).map((entry) => {
+    const path = join2(extensionsDir, entry.name);
+    const content = readTextIfExists(path);
+    return content === null ? null : parseSkillExtension(path, content);
+  }).filter((entry) => Boolean(entry)).sort((left, right) => left.id.localeCompare(right.id));
+}
+function addSkillExtension(options) {
+  const skillId = normalizeSkillId(options.skillId);
+  const scope = normalizeSkillExtensionScope(options.scope);
+  const path = extensionFilePath(skillId, scope, options.extensionsDir);
+  const title = options.title?.trim() || defaultExtensionTitle(skillId, scope);
+  const existing = readTextIfExists(path);
+  if (existing !== null && options.overwrite !== true) {
+    const extension2 = parseSkillExtension(path, existing);
+    if (!extension2) {
+      throw new Error(`Could not parse existing skill extension at ${path}.`);
+    }
+    return {
+      changed: false,
+      created: false,
+      extension: extension2,
+      path
+    };
+  }
+  const nextContent = extensionTemplate({
+    scope,
+    skillId,
+    title,
+    ...options.content !== void 0 ? { content: options.content } : {}
+  });
+  writeTextFile(path, nextContent);
+  const extension = parseSkillExtension(path, nextContent);
+  if (!extension) {
+    throw new Error(`Could not parse newly written skill extension at ${path}.`);
+  }
+  return {
+    changed: existing !== nextContent,
+    created: existing === null,
+    extension,
+    path
+  };
+}
+function setSkillExtensionEnabled(input) {
+  const skillId = normalizeSkillId(input.skillId);
+  const scope = normalizeSkillExtensionScope(input.scope);
+  const path = extensionFilePath(skillId, scope, input.extensionsDir);
+  const existing = readTextIfExists(path);
+  if (existing === null) {
+    if (!input.enabled) {
+      throw new Error(`No ${scope} extension exists for ${skillId}.`);
+    }
+    return addSkillExtension({
+      scope,
+      skillId,
+      ...input.extensionsDir !== void 0 ? { extensionsDir: input.extensionsDir } : {}
+    });
+  }
+  const parsed = parseFrontmatter(existing);
+  const data = {
+    skill: parsed.data.skill || skillId,
+    scope: parsed.data.scope || scope,
+    enabled: input.enabled ? "true" : "false",
+    title: parsed.data.title || defaultExtensionTitle(skillId, scope)
+  };
+  const nextContent = serializeFrontmatter(data, parsed.body);
+  if (nextContent !== existing) {
+    writeTextFile(path, nextContent);
+  }
+  const extension = parseSkillExtension(path, nextContent);
+  if (!extension) {
+    throw new Error(`Could not parse skill extension at ${path}.`);
+  }
+  return {
+    changed: nextContent !== existing,
+    created: false,
+    extension,
+    path
+  };
+}
+function composeSkillContent(skillId, coreContent, extensions) {
+  const enabled = extensions.filter((extension) => extension.enabled && extension.skillId === skillId);
+  if (enabled.length === 0) {
+    return coreContent;
+  }
+  const extensionBlocks = enabled.map((extension) => [
+    `<!-- extension: ${extension.id} -->`,
+    extension.content.trim()
+  ].join("\n"));
+  return [
+    `<!-- ${COMPOSED_SKILL_MARKER}`,
+    `skill: ${skillId}`,
+    `core-sha256: ${sha256(coreContent)}`,
+    "generated: true",
+    `edit-with: orgx-wizard skills extensions edit ${skillId}`,
+    "-->",
+    `<!-- ORGX CORE BEGIN ${skillId} -->`,
+    coreContent.trimEnd(),
+    `<!-- ORGX CORE END ${skillId} -->`,
+    "",
+    "<!-- ORGX USER EXTENSIONS BEGIN -->",
+    ...extensionBlocks,
+    "<!-- ORGX USER EXTENSIONS END -->",
+    ""
+  ].join("\n");
+}
 function encodeRepoPath(value) {
   return value.split("/").filter((segment) => segment.length > 0).map((segment) => encodeURIComponent(segment)).join("/");
 }
@@ -3137,12 +3396,35 @@ async function fetchRemoteText(sourceUrl, fetchImpl) {
   }
   return readResponseText(response);
 }
-function writeManagedFile(path, content, label, sourceUrl) {
+function getTrackedSkillFile(records, path) {
+  return records.find((record) => record.path === path);
+}
+function writeManagedFile(path, content, label, sourceUrl, tracking) {
   const existing = readTextIfExists(path);
+  const tracked = tracking ? getTrackedSkillFile(tracking.records, path) : void 0;
+  if (tracking && existing !== null && tracked && sha256(existing) !== tracked.contentSha256 && tracking.force !== true) {
+    return {
+      label,
+      path,
+      changed: false,
+      skipped: true,
+      reason: "manual edits detected; move them into a skill extension or rerun with --force",
+      ...sourceUrl ? { sourceUrl } : {}
+    };
+  }
   const changed = existing !== content;
   if (changed) {
     writeTextFile(path, content);
   }
+  if (tracking) {
+    tracking.stagedRecords.set(path, {
+      contentSha256: sha256(content),
+      ...tracking.coreContent ? { coreSha256: sha256(tracking.coreContent) } : {},
+      path,
+      skillId: tracking.skillId,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
   return {
     label,
     path,
@@ -3207,19 +3489,27 @@ async function fetchAvailablePackNames(fetchImpl, ref) {
   const entries = await fetchDirectoryEntries("", fetchImpl, ref);
   return entries.filter((e) => e.type === "dir" && !EXCLUDED_PACK_DIRS.has(e.name)).map((e) => e.name);
 }
-async function installSkillPack(skillName, claudeSkillsDir, fetchImpl, ref) {
+async function installSkillPack(skillName, claudeSkillsDir, fetchImpl, ref, tracking) {
   const rootPath = skillName;
   const files = await listRemoteSkillFiles(rootPath, fetchImpl, ref);
   const writes = [];
   for (const file of files) {
-    const content = await fetchRemoteText(file.sourceUrl, fetchImpl);
+    const coreContent = await fetchRemoteText(file.sourceUrl, fetchImpl);
     const relativePath = file.path.slice(`${rootPath}/`.length);
+    const content = relativePath === "SKILL.md" ? composeSkillContent(skillName, coreContent, tracking.extensions) : coreContent;
     writes.push(
       writeManagedFile(
         join2(claudeSkillsDir, skillName, relativePath),
         content,
         `${skillName}/${relativePath}`,
-        file.sourceUrl
+        file.sourceUrl,
+        {
+          coreContent,
+          records: tracking.records,
+          skillId: skillName,
+          stagedRecords: tracking.stagedRecords,
+          ...tracking.force !== void 0 ? { force: tracking.force } : {}
+        }
       )
     );
   }
@@ -3237,6 +3527,13 @@ async function installOrgxSkills(options = {}) {
   const claudeSkillsDir = options.claudeSkillsDir ?? CLAUDE_SKILLS_DIR;
   const claudeOrgxSkillPath = options.claudeOrgxSkillPath ?? CLAUDE_ORGX_SKILL_PATH;
   const cursorRulePath = options.cursorRulePath ?? CURSOR_ORGX_RULE_PATH;
+  const statePath = options.statePath ?? ORGX_WIZARD_STATE_PATH;
+  const extensions = listSkillExtensions(
+    options.skillExtensionsDir !== void 0 ? { extensionsDir: options.skillExtensionsDir } : {}
+  );
+  const enabledExtensions = extensions.filter((extension) => extension.enabled);
+  const trackedRecords = readWizardState(statePath)?.skillFiles?.files ?? [];
+  const stagedRecords = /* @__PURE__ */ new Map();
   const plan = planOrgxSkillsInstall(options.pluginTargets ?? []);
   const requestedNames = options.skillNames ?? [];
   let skillNames;
@@ -3250,34 +3547,101 @@ async function installOrgxSkills(options = {}) {
     skillNames = resolveSkillPackNames(requestedNames);
   }
   const writes = [
-    writeManagedFile(cursorRulePath, CURSOR_RULES_CONTENT, "cursor-rules")
+    writeManagedFile(
+      cursorRulePath,
+      composeSkillContent("cursor-rules", CURSOR_RULES_CONTENT, extensions),
+      "cursor-rules",
+      void 0,
+      {
+        coreContent: CURSOR_RULES_CONTENT,
+        records: trackedRecords,
+        skillId: "cursor-rules",
+        stagedRecords,
+        ...options.force !== void 0 ? { force: options.force } : {}
+      }
+    )
   ];
   if (plan.installClaudeSkillBootstrap) {
     writes.push(
-      writeManagedFile(claudeOrgxSkillPath, CLAUDE_ORGX_SKILL_CONTENT, "claude-orgx-skill")
+      writeManagedFile(
+        claudeOrgxSkillPath,
+        composeSkillContent("orgx", CLAUDE_ORGX_SKILL_CONTENT, extensions),
+        "claude-orgx-skill",
+        void 0,
+        {
+          coreContent: CLAUDE_ORGX_SKILL_CONTENT,
+          records: trackedRecords,
+          skillId: "orgx",
+          stagedRecords,
+          ...options.force !== void 0 ? { force: options.force } : {}
+        }
+      )
     );
   }
   const packs = [];
   if (plan.installClaudeSkillPacks) {
     for (const skillName of skillNames) {
-      packs.push(await installSkillPack(skillName, claudeSkillsDir, fetchImpl, ref));
+      packs.push(await installSkillPack(skillName, claudeSkillsDir, fetchImpl, ref, {
+        extensions,
+        records: trackedRecords,
+        stagedRecords,
+        ...options.force !== void 0 ? { force: options.force } : {}
+      }));
     }
   }
+  if (stagedRecords.size > 0) {
+    updateWizardState((current) => {
+      const previousFiles = current.skillFiles?.files ?? [];
+      const nextFiles = /* @__PURE__ */ new Map();
+      for (const record of previousFiles) {
+        nextFiles.set(record.path, record);
+      }
+      for (const record of stagedRecords.values()) {
+        nextFiles.set(record.path, record);
+      }
+      return {
+        ...current,
+        skillFiles: {
+          files: [...nextFiles.values()].sort((left, right) => left.path.localeCompare(right.path)),
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      };
+    }, statePath);
+  }
+  const notes = [...plan.notes];
+  if (enabledExtensions.length > 0) {
+    notes.push(
+      `Applied ${enabledExtensions.length} enabled OrgX skill extension${enabledExtensions.length === 1 ? "" : "s"} while syncing skills/rules.`
+    );
+  }
+  if (writes.some((write) => write.skipped) || packs.some((pack) => pack.files.some((file) => file.skipped))) {
+    notes.push("Some generated skill files were skipped because local manual edits were detected.");
+  }
   return {
-    notes: plan.notes,
+    extensions,
+    notes,
     writes,
     packs
   };
 }
+function getSkillStatus(options = {}) {
+  const state = readWizardState(options.statePath ?? ORGX_WIZARD_STATE_PATH);
+  return {
+    extensions: listSkillExtensions(
+      options.extensionsDir !== void 0 ? { extensionsDir: options.extensionsDir } : {}
+    ),
+    trackedFiles: state?.skillFiles?.files ?? []
+  };
+}
 
 // src/lib/plugins.ts
 import { spawn } from "child_process";
 import {
-  existsSync as existsSync3,
+  existsSync as existsSync4,
   mkdirSync as mkdirSync2,
   mkdtempSync,
   readFileSync as readFileSync2,
-  readdirSync,
+  readdirSync as readdirSync2,
   rmSync,
   statSync as statSync2,
   writeFileSync as writeFileSync2
@@ -3290,6 +3654,7 @@ var ORGX_PLUGIN_GITHUB_REF = "main";
 var ORGX_CLAUDE_PLUGIN_NAME = "orgx-claude-code-plugin";
 var ORGX_CLAUDE_MARKETPLACE_NAME = "orgx-local";
 var ORGX_CODEX_PLUGIN_NAME = "orgx-codex-plugin";
+var ORGX_CURSOR_PLUGIN_NAME = "cursor-plugin";
 var ORGX_OPENCLAW_PLUGIN_ID = "orgx";
 var ORGX_OPENCLAW_PLUGIN_PACKAGE_NAME = "@useorgx/openclaw-plugin";
 var CLAUDE_PLUGIN_SYNC_SPEC = {
@@ -3317,6 +3682,22 @@ var CODEX_PLUGIN_SYNC_SPEC = {
     { localPath: "skills", remotePath: "skills" }
   ]
 };
+var CURSOR_PLUGIN_SYNC_SPEC = {
+  owner: ORGX_PLUGIN_GITHUB_OWNER,
+  repo: ORGX_CURSOR_PLUGIN_NAME,
+  ref: ORGX_PLUGIN_GITHUB_REF,
+  include: [
+    { localPath: ".cursor-plugin", remotePath: ".cursor-plugin" },
+    { localPath: ".mcp.json", remotePath: ".mcp.json" },
+    { localPath: "agents", remotePath: "agents" },
+    { localPath: "assets", remotePath: "assets" },
+    { localPath: "commands", remotePath: "commands" },
+    { localPath: "hooks", remotePath: "hooks" },
+    { localPath: "rules", remotePath: "rules" },
+    { localPath: "scripts", remotePath: "scripts" },
+    { localPath: "skills", remotePath: "skills" }
+  ]
+};
 function defaultPluginPaths() {
   return {
     claudeMarketplaceDir: CLAUDE_MANAGED_MARKETPLACE_DIR,
@@ -3324,6 +3705,7 @@ function defaultPluginPaths() {
     claudePluginDir: CLAUDE_MANAGED_PLUGIN_DIR,
     codexMarketplacePath: CODEX_MARKETPLACE_PATH,
     codexPluginDir: CODEX_ORGX_PLUGIN_DIR,
+    cursorPluginDir: CURSOR_ORGX_PLUGIN_DIR,
     cursorRulePath: CURSOR_ORGX_RULE_PATH
   };
 }
@@ -3343,8 +3725,8 @@ function encodeRepoPath2(value) {
   return value.split("/").filter((segment) => segment.length > 0).map((segment) => encodeURIComponent(segment)).join("/");
 }
 function isLikelyRepoFilePath(path) {
-  const basename = path.split("/").pop() ?? path;
-  return basename.includes(".") && !/^\.[^./]+$/.test(basename);
+  const basename2 = path.split("/").pop() ?? path;
+  return basename2.includes(".") && !/^\.[^./]+$/.test(basename2);
 }
 function buildContentsUrl2(spec, path) {
   const encodedPath = encodeRepoPath2(path);
@@ -3454,7 +3836,7 @@ async function fetchRemoteBytes(sourceUrl, fetchImpl) {
   return Buffer.from(await response.arrayBuffer());
 }
 function readBytesIfExists(path) {
-  if (!existsSync3(path)) return null;
+  if (!existsSync4(path)) return null;
   try {
     if (!statSync2(path).isFile()) {
       return null;
@@ -3478,17 +3860,17 @@ function writeBytesIfChanged(path, bytes) {
   return true;
 }
 function removePathIfExists(path) {
-  if (!existsSync3(path)) return false;
+  if (!existsSync4(path)) return false;
   rmSync(path, { force: true, recursive: true });
   return true;
 }
 function listRelativeFiles(root, base = root) {
-  if (!existsSync3(root)) return [];
+  if (!existsSync4(root)) return [];
   if (!statSync2(root).isDirectory()) {
     return [];
   }
   const files = [];
-  for (const entry of readdirSync(root, { withFileTypes: true })) {
+  for (const entry of readdirSync2(root, { withFileTypes: true })) {
     const nextPath = join3(root, entry.name);
     if (entry.isDirectory()) {
       files.push(...listRelativeFiles(nextPath, base));
@@ -3501,15 +3883,15 @@ function listRelativeFiles(root, base = root) {
   return files.sort();
 }
 function pruneEmptyDirectories(root, current = root) {
-  if (!existsSync3(current) || !statSync2(current).isDirectory()) {
+  if (!existsSync4(current) || !statSync2(current).isDirectory()) {
     return false;
   }
   let changed = false;
-  for (const entry of readdirSync(current, { withFileTypes: true })) {
+  for (const entry of readdirSync2(current, { withFileTypes: true })) {
     if (!entry.isDirectory()) continue;
     changed = pruneEmptyDirectories(root, join3(current, entry.name)) || changed;
   }
-  if (current !== root && readdirSync(current).length === 0) {
+  if (current !== root && readdirSync2(current).length === 0) {
     rmSync(current, { force: true, recursive: true });
     return true;
   }
@@ -3519,7 +3901,7 @@ async function syncManagedRepoTree(spec, destinationRoot, fetchImpl) {
   const remoteFiles = await collectRemoteRepoFiles(spec, fetchImpl);
   let changed = false;
   const expected = new Set(remoteFiles.map((file) => file.localPath));
-  if (existsSync3(destinationRoot) && !statSync2(destinationRoot).isDirectory()) {
+  if (existsSync4(destinationRoot) && !statSync2(destinationRoot).isDirectory()) {
     rmSync(destinationRoot, { force: true, recursive: true });
     changed = true;
   }
@@ -3610,7 +3992,7 @@ function upsertCodexMarketplaceEntry(path) {
   return writeJsonIfChanged(path, nextDocument);
 }
 function removeCodexMarketplaceEntry(path) {
-  if (!existsSync3(path)) {
+  if (!existsSync4(path)) {
     return false;
   }
   const { document, plugins } = readMarketplacePlugins(path);
@@ -3744,15 +4126,36 @@ async function getOpenclawInstallState(runner) {
     installed: extractOpenclawPluginIds(result.stdout).includes(ORGX_OPENCLAW_PLUGIN_ID)
   };
 }
+function cursorPluginManifestPath(paths) {
+  return join3(paths.cursorPluginDir, ".cursor-plugin", "plugin.json");
+}
+function cursorPluginMcpPath(paths) {
+  return join3(paths.cursorPluginDir, ".mcp.json");
+}
+function isCursorPluginInstalled(paths) {
+  return existsSync4(cursorPluginManifestPath(paths)) && existsSync4(cursorPluginMcpPath(paths));
+}
+function isCursorPluginAvailable(paths) {
+  return detectSurface("cursor").detected || existsSync4(paths.cursorPluginDir) || existsSync4(dirname3(paths.cursorPluginDir)) || readTextIfExists(paths.cursorRulePath) !== null;
+}
 function buildCursorStatus(paths) {
   const existingRules = readTextIfExists(paths.cursorRulePath);
-  const available = detectSurface("cursor").detected || existingRules !== null;
-  if (existingRules === CURSOR_RULES_CONTENT) {
+  const available = isCursorPluginAvailable(paths);
+  const installed = isCursorPluginInstalled(paths);
+  if (installed) {
     return {
       target: "cursor",
       available: true,
       installed: true,
-      message: "Cursor OrgX rules are installed."
+      message: "Cursor OrgX plugin bundle is installed."
+    };
+  }
+  if (existingRules === CURSOR_RULES_CONTENT) {
+    return {
+      target: "cursor",
+      available: true,
+      installed: false,
+      message: "Legacy Cursor OrgX rules are installed; run plugins add cursor to install the full plugin bundle."
     };
   }
   if (existingRules !== null) {
@@ -3760,14 +4163,14 @@ function buildCursorStatus(paths) {
       target: "cursor",
       available: true,
       installed: false,
-      message: "Cursor OrgX rules file exists, but differs from the managed rules."
+      message: "Cursor rules file exists, but the OrgX plugin bundle is missing."
     };
   }
   return {
     target: "cursor",
     available,
     installed: false,
-    message: available ? "Cursor is available and ready for OrgX rules install." : "Cursor was not detected."
+    message: available ? "Cursor is available and ready for OrgX plugin install." : "Cursor was not detected."
   };
 }
 async function buildClaudeStatus(paths, runner) {
@@ -3788,7 +4191,7 @@ async function buildClaudeStatus(paths, runner) {
       message: "Claude Code was not detected."
     };
   }
-  const marketplaceExists = existsSync3(paths.claudeMarketplaceManifestPath);
+  const marketplaceExists = existsSync4(paths.claudeMarketplaceManifestPath);
   return {
     target: "claude",
     available: true,
@@ -3799,7 +4202,7 @@ async function buildClaudeStatus(paths, runner) {
 function buildCodexStatus(paths, runner) {
   return (async () => {
     const available = detectSurface("codex").detected || await commandExists("codex", runner);
-    const pluginExists = existsSync3(paths.codexPluginDir);
+    const pluginExists = existsSync4(paths.codexPluginDir);
     const marketplaceExists = codexMarketplaceHasOrgxEntry(paths.codexMarketplacePath);
     const installed = pluginExists && marketplaceExists;
     if (installed) {
@@ -3885,28 +4288,19 @@ async function resolveOpenclawTarball(fetchImpl) {
     version: latestVersion
   };
 }
-function installCursorPlugin(paths) {
-  const existingRules = readTextIfExists(paths.cursorRulePath);
-  const available = detectSurface("cursor").detected || existingRules !== null;
-  if (!available) {
+async function installCursorPlugin(paths, fetchImpl) {
+  if (!isCursorPluginAvailable(paths)) {
     return {
       target: "cursor",
       changed: false,
       message: "Cursor is not available on this machine."
     };
   }
-  if (existingRules === CURSOR_RULES_CONTENT) {
-    return {
-      target: "cursor",
-      changed: false,
-      message: "Cursor OrgX rules are already installed."
-    };
-  }
-  writeTextFile(paths.cursorRulePath, CURSOR_RULES_CONTENT);
+  const syncResult = await syncManagedRepoTree(CURSOR_PLUGIN_SYNC_SPEC, paths.cursorPluginDir, fetchImpl);
   return {
     target: "cursor",
-    changed: true,
-    message: "Installed the managed Cursor OrgX rules."
+    changed: syncResult.changed,
+    message: syncResult.changed ? `Synced ${syncResult.fileCount} Cursor plugin files into ${paths.cursorPluginDir}. Reload Cursor to finish loading the plugin.` : "Cursor plugin bundle is already installed and up to date."
   };
 }
 async function installClaudePlugin(paths, fetchImpl, runner) {
@@ -4017,25 +4411,13 @@ async function installOpenclawPlugin(fetchImpl, runner) {
 }
 function uninstallCursorPlugin(paths) {
   const existingRules = readTextIfExists(paths.cursorRulePath);
-  if (existingRules === null) {
-    return {
-      target: "cursor",
-      changed: false,
-      message: "Cursor OrgX rules were not installed."
-    };
-  }
-  if (existingRules !== CURSOR_RULES_CONTENT) {
-    return {
-      target: "cursor",
-      changed: false,
-      message: "Cursor rules file differs from the managed OrgX rules, so it was left in place."
-    };
-  }
-  const changed = deleteFileIfExists(paths.cursorRulePath);
+  const removedPluginDir = removePathIfExists(paths.cursorPluginDir);
+  const removedLegacyRules = existingRules === CURSOR_RULES_CONTENT ? deleteFileIfExists(paths.cursorRulePath) : false;
+  const changed = removedPluginDir || removedLegacyRules;
   return {
     target: "cursor",
     changed,
-    message: changed ? "Removed the managed Cursor OrgX rules." : "Cursor OrgX rules were not installed."
+    message: changed ? existingRules !== null && existingRules !== CURSOR_RULES_CONTENT ? "Removed the managed Cursor OrgX plugin bundle. Existing Cursor rules differ from managed OrgX rules, so they were left in place." : "Removed the managed Cursor OrgX plugin bundle and legacy managed Cursor rules." : existingRules !== null && existingRules !== CURSOR_RULES_CONTENT ? "Cursor plugin was not installed. Existing Cursor rules differ from managed OrgX rules, so they were left in place." : "Cursor plugin was not installed."
   };
 }
 async function uninstallClaudePlugin(paths, runner) {
@@ -4151,7 +4533,7 @@ async function installOrgxPlugins(options = {}) {
   for (const target of targets) {
     switch (target) {
       case "cursor":
-        results.push(installCursorPlugin(paths));
+        results.push(await installCursorPlugin(paths, fetchImpl));
         break;
       case "claude":
         results.push(await installClaudePlugin(paths, fetchImpl, runner));
@@ -4643,7 +5025,7 @@ function formatAuthSource(source) {
 function formatPluginTargetLabel(target) {
   switch (target) {
     case "cursor":
-      return "Cursor rules";
+      return "Cursor plugin";
     case "claude":
       return "Claude Code";
     case "codex":
@@ -4689,10 +5071,10 @@ function printPluginMutationReport(report) {
   }
 }
 async function printPluginStatusSection() {
-  const spinner = createOrgxSpinner("Checking OrgX plugin and Cursor rules status");
+  const spinner = createOrgxSpinner("Checking OrgX companion plugin status");
   spinner.start();
   const statuses = await listOrgxPluginStatuses();
-  spinner.succeed("OrgX plugin and Cursor rules status checked");
+  spinner.succeed("OrgX companion plugin status checked");
   console.log("");
   console.log(pc3.dim("  plugins"));
   printPluginStatusReport(statuses);
@@ -4700,28 +5082,67 @@ async function printPluginStatusSection() {
 }
 function printSkillInstallReport(report) {
   for (const write of report.writes) {
-    const icon = write.changed ? ICON.ok : ICON.skip;
-    const state = write.changed ? pc3.green("updated  ") : pc3.dim("unchanged");
+    const icon = write.skipped ? ICON.warn : write.changed ? ICON.ok : ICON.skip;
+    const state = write.skipped ? pc3.yellow("skipped  ") : write.changed ? pc3.green("updated  ") : pc3.dim("unchanged");
     console.log(`  ${icon}  ${pc3.bold(write.label.padEnd(10))} ${state}`);
+    if (write.reason) {
+      console.log(`       ${pc3.dim(write.reason)}`);
+    }
   }
   for (const pack of report.packs) {
     const changedCount = pack.files.filter((f) => f.changed).length;
-    const icon = changedCount > 0 ? ICON.ok : ICON.skip;
-    const state = changedCount > 0 ? pc3.green(`${changedCount} updated `) : pc3.dim("unchanged");
+    const skippedCount = pack.files.filter((f) => f.skipped).length;
+    const icon = skippedCount > 0 ? ICON.warn : changedCount > 0 ? ICON.ok : ICON.skip;
+    const state = skippedCount > 0 ? pc3.yellow(`${skippedCount} skipped `) : changedCount > 0 ? pc3.green(`${changedCount} updated `) : pc3.dim("unchanged");
     console.log(`  ${icon}  ${pc3.bold(pack.name.padEnd(10))} ${state}  ${pc3.dim(`${pack.files.length} files`)}`);
+    for (const file of pack.files.filter((entry) => entry.skipped && entry.reason)) {
+      console.log(`       ${pc3.dim(`${file.label}: ${file.reason}`)}`);
+    }
   }
   for (const note of report.notes) {
     console.log(`  ${ICON.skip}  ${pc3.dim(note)}`);
   }
 }
 function countSkillReportChanges(report) {
-  const writeChanges = report.writes.filter((write) => write.changed).length;
+  const writeChanges = report.writes.filter((write) => write.changed && !write.skipped).length;
   const packChanges = report.packs.reduce(
-    (count, pack) => count + pack.files.filter((file) => file.changed).length,
+    (count, pack) => count + pack.files.filter((file) => file.changed && !file.skipped).length,
     0
   );
   return writeChanges + packChanges;
 }
+function printSkillExtensions(extensions) {
+  if (extensions.length === 0) {
+    console.log(`  ${ICON.skip}  ${pc3.dim("no skill extensions yet")}`);
+    return;
+  }
+  for (const extension of extensions) {
+    const icon = extension.enabled ? ICON.ok : ICON.skip;
+    const state = extension.enabled ? pc3.green("enabled  ") : pc3.dim("disabled ");
+    console.log(
+      `  ${icon}  ${pc3.bold(extension.id.padEnd(24))} ${state} ${pc3.dim(extension.path)}`
+    );
+  }
+}
+function printSkillExtensionWrite(result) {
+  const action = result.created ? "created" : result.changed ? "updated" : "unchanged";
+  const color = result.created || result.changed ? pc3.green : pc3.dim;
+  console.log(
+    `  ${result.created || result.changed ? ICON.ok : ICON.skip}  ${pc3.bold(result.extension.id.padEnd(24))} ${color(action)}`
+  );
+  console.log(`       ${pc3.dim(result.path)}`);
+}
+function openPathInEditor(path) {
+  const editor = process.env.EDITOR || process.env.VISUAL;
+  if (!editor) {
+    return false;
+  }
+  const result = spawnSync3(editor, [path], {
+    shell: true,
+    stdio: "inherit"
+  });
+  return result.status === 0;
+}
 async function safeTrackWizardTelemetry(event, properties = {}) {
   try {
     await trackWizardTelemetry(event, properties);
@@ -5012,17 +5433,18 @@ async function promptOptionalCompanionPluginTargets(input) {
   }
   let statuses = input.statuses;
   if (!statuses) {
-    const spinner = createOrgxSpinner("Checking optional OrgX plugin and Cursor rules status");
+    const spinner = createOrgxSpinner("Checking optional OrgX companion plugin status");
     spinner.start();
     statuses = await listOrgxPluginStatuses();
-    spinner.succeed("Optional OrgX plugin and Cursor rules status checked");
+    spinner.succeed("Optional OrgX companion plugin status checked");
   }
   const installable = statuses.filter((status) => status.available && !status.installed);
   if (installable.length === 0) {
     return [];
   }
   const selection = await multiselectPrompt({
-    message: "Install companion OrgX plugins into detected tools?",
+    initialValues: installable.map((status) => status.target),
+    message: "Install OrgX companion plugins into your detected AI tools?",
     options: installable.map((status) => ({
       value: status.target,
       label: `Install ${formatPluginTargetLabel(status.target)}`,
@@ -5037,12 +5459,12 @@ async function promptOptionalCompanionPluginTargets(input) {
   return selection;
 }
 function printPluginSkillOwnershipNote(targets) {
-  if (!targets.some((target) => target === "claude" || target === "codex")) {
+  if (!targets.some((target) => target === "cursor" || target === "claude" || target === "codex")) {
     return;
   }
   console.log(
     `  ${ICON.skip}  ${pc3.dim(
-      "Claude Code and Codex companion plugins carry their own OrgX skills. Use 'wizard skills add' for Cursor rules or standalone Claude setup when those plugins are not in play."
+      "Cursor, Claude Code, and Codex companion plugins carry their own OrgX skills, rules, MCP config, commands, hooks, and agent prompts. Use 'wizard skills add' only for standalone rules or skills when those plugins are not in play."
     )}`
   );
 }
@@ -5155,13 +5577,13 @@ function printDoctorReport(report, assessment) {
 }
 async function main() {
   const program = new Command();
-  program.name("orgx-wizard").description("One-line CLI onboarding for OrgX surfaces.").showHelpAfterError();
-  const pkgVersion = true ? "0.1.10" : void 0;
+  program.name("orgx-wizard").description("Add OrgX MCP configs, skills/rules, and companion plugins to your local AI tools.").showHelpAfterError();
+  const pkgVersion = true ? "0.1.12" : void 0;
   program.version(pkgVersion ?? "unknown", "-V, --version");
   program.hook("preAction", () => {
     console.log(renderBanner(pkgVersion));
   });
-  program.command("setup").description("Patch all detected automated OrgX surfaces.").option("--preset <name>", "run a setup bundle (currently: founder)").action(async (options) => {
+  program.command("setup").description("Add OrgX MCP configs, skills/rules, and companion plugins to detected tools.").option("--preset <name>", "run a setup bundle (currently: founder)").action(async (options) => {
     const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY);
     await safeTrackWizardTelemetry("wizard_started", {
       command: "setup",
@@ -5527,7 +5949,7 @@ async function main() {
       );
     }
   });
-  program.command("uninstall").description("Remove OrgX-managed surfaces, companion plugins/rules, auth, and wizard state from this machine.").option("--keep-auth", "Keep the wizard-local saved OrgX API key.").option("--keep-state", "Keep wizard-local setup state.").option("--skip-plugins", "Skip companion plugin and Cursor rules removal.").option("--skip-surfaces", "Skip MCP surface config removal.").action(async (options) => {
+  program.command("uninstall").description("Remove OrgX-managed MCP tool configs, companion plugins, auth, and wizard state from this machine.").option("--keep-auth", "Keep the wizard-local saved OrgX API key.").option("--keep-state", "Keep wizard-local setup state.").option("--skip-plugins", "Skip companion plugin and legacy Cursor rules removal.").option("--skip-surfaces", "Skip MCP tool config removal.").action(async (options) => {
     await safeTrackWizardTelemetry("wizard_uninstalled", {
       keep_auth: Boolean(options.keepAuth),
       keep_state: Boolean(options.keepState),
@@ -5548,10 +5970,10 @@ async function main() {
     } else {
       console.log("");
       console.log(pc3.dim("  plugins"));
-      const spinner = createOrgxSpinner("Removing OrgX companion plugins and rules");
+      const spinner = createOrgxSpinner("Removing OrgX companion plugins and legacy Cursor rules");
       spinner.start();
       const pluginReport = await uninstallOrgxPlugins({ targets: ["all"] });
-      spinner.succeed("OrgX companion plugins and rules processed");
+      spinner.succeed("OrgX companion plugins and legacy Cursor rules processed");
       printPluginMutationReport(pluginReport);
     }
     console.log("");
@@ -5584,24 +6006,24 @@ async function main() {
     const results = removeSurface(names);
     printMutationResults(results);
   });
-  const mcp = program.command("mcp").description("Manage OrgX MCP entries for Claude, Cursor, Codex, VS Code, Windsurf, and Zed.");
-  mcp.command("add").description("Add OrgX MCP entries to one client or all supported MCP clients.").argument("[surfaces...]", "claude, cursor, codex, vscode, windsurf, zed, or all", ["all"]).action(async (names) => {
+  const mcp = program.command("mcp").description("Add or remove OrgX MCP config entries in Claude, Cursor, Codex, VS Code, Windsurf, and Zed.");
+  mcp.command("add").description("Add OrgX MCP entries to one tool config or all supported MCP tool configs.").argument("[surfaces...]", "claude, cursor, codex, vscode, windsurf, zed, or all", ["all"]).action(async (names) => {
     const results = await addMcpSurface(names);
     printMutationResults(results);
   });
-  mcp.command("remove").description("Remove OrgX MCP entries from one client or all supported MCP clients.").argument("[surfaces...]", "claude, cursor, codex, vscode, windsurf, zed, or all", ["all"]).action((names) => {
+  mcp.command("remove").description("Remove OrgX MCP entries from one tool config or all supported MCP tool configs.").argument("[surfaces...]", "claude, cursor, codex, vscode, windsurf, zed, or all", ["all"]).action((names) => {
     const results = removeMcpSurface(names);
     printMutationResults(results);
   });
-  const plugins = program.command("plugins").description("Install or remove Cursor rules and companion OrgX plugins for Claude Code, Codex, and OpenClaw.");
-  plugins.command("list").description("Show companion plugin availability and install status.").action(async () => {
-    const spinner = createOrgxSpinner("Checking OrgX plugin and Cursor rules status");
+  const plugins = program.command("plugins").description("Install or remove OrgX companion plugins in Cursor, Claude Code, Codex, and OpenClaw.");
+  plugins.command("list").description("Show companion plugin availability and install status in your tools.").action(async () => {
+    const spinner = createOrgxSpinner("Checking OrgX companion plugin status");
     spinner.start();
     const statuses = await listOrgxPluginStatuses();
-    spinner.succeed("OrgX plugin and Cursor rules status checked");
+    spinner.succeed("OrgX companion plugin status checked");
     printPluginStatusReport(statuses);
   });
-  plugins.command("add").description("Install Cursor OrgX rules or companion plugins into Claude Code, Codex, and OpenClaw.").argument("[targets...]", "cursor, claude, codex, openclaw, or all", ["all"]).action(async (targets) => {
+  plugins.command("add").description("Install OrgX companion plugins into Cursor, Claude Code, Codex, and OpenClaw.").argument("[targets...]", "cursor, claude, codex, openclaw, or all", ["all"]).action(async (targets) => {
     const spinner = createOrgxSpinner("Installing OrgX companion plugins");
     spinner.start();
     const report = await installOrgxPlugins({ targets });
@@ -5615,11 +6037,11 @@ async function main() {
       target_count: report.results.length
     });
   });
-  plugins.command("remove").description("Uninstall managed Cursor OrgX rules or companion plugins from Claude Code, Codex, and OpenClaw.").argument("[targets...]", "cursor, claude, codex, openclaw, or all", ["all"]).action(async (targets) => {
-    const spinner = createOrgxSpinner("Removing OrgX companion plugins");
+  plugins.command("remove").description("Uninstall managed OrgX companion plugins and legacy managed Cursor rules from Cursor, Claude Code, Codex, and OpenClaw.").argument("[targets...]", "cursor, claude, codex, openclaw, or all", ["all"]).action(async (targets) => {
+    const spinner = createOrgxSpinner("Removing OrgX companion plugins and legacy Cursor rules");
     spinner.start();
     const report = await uninstallOrgxPlugins({ targets });
-    spinner.succeed("OrgX companion plugins removed");
+    spinner.succeed("OrgX companion plugins and legacy Cursor rules processed");
     printPluginMutationReport(report);
     await safeTrackWizardTelemetry("plugins_removed", {
       changed_count: countPluginReportChanges(report),
@@ -5694,16 +6116,17 @@ async function main() {
       process.exitCode = 1;
     }
   });
-  const skills = program.command("skills").description("Install OrgX rules and Claude skill packs.");
-  skills.command("add").description("Write standalone OrgX editor rules and Claude skill packs, skipping surfaces already owned by companion plugins.").argument("[packs...]", "skill pack names or 'all'", ["all"]).action(async (packs) => {
+  const skills = program.command("skills").description("Install OrgX skills and rules into supported local tools.");
+  skills.command("add").description("Write standalone OrgX Cursor rules and Claude skills, skipping tool surfaces already owned by companion plugins.").argument("[packs...]", "skill pack names or 'all'", ["all"]).option("--force", "Overwrite generated skill files even when manual edits are detected.").action(async (packs, options) => {
     const pluginTargets = (await listOrgxPluginStatuses()).filter((status) => status.installed).map((status) => status.target);
-    const spinner = createOrgxSpinner("Installing OrgX rules and skills");
+    const spinner = createOrgxSpinner("Installing OrgX skills/rules into tools");
     spinner.start();
     const report = await installOrgxSkills({
+      force: options.force === true,
       pluginTargets,
       skillNames: packs
     });
-    spinner.succeed("OrgX rules and skills installed");
+    spinner.succeed("OrgX skills/rules installed into tools");
     printSkillInstallReport(report);
     await safeTrackWizardTelemetry("skills_installed", {
       changed_count: countSkillReportChanges(report),
@@ -5711,9 +6134,99 @@ async function main() {
       pack_count: report.packs.length,
       plugin_managed_target_count: pluginTargets.length,
       requested_pack_count: packs.length,
+      skill_extension_count: report.extensions.length,
+      write_count: report.writes.length
+    });
+  });
+  skills.command("sync").description("Recompose installed OrgX skills/rules from core skills plus local extensions.").argument("[packs...]", "skill pack names or 'all'", ["all"]).option("--force", "Overwrite generated skill files even when manual edits are detected.").action(async (packs, options) => {
+    const pluginTargets = (await listOrgxPluginStatuses()).filter((status) => status.installed).map((status) => status.target);
+    const spinner = createOrgxSpinner("Syncing OrgX skills/rules and extensions into tools");
+    spinner.start();
+    const report = await installOrgxSkills({
+      force: options.force === true,
+      pluginTargets,
+      skillNames: packs
+    });
+    spinner.succeed("OrgX skills/rules synced into tools");
+    printSkillInstallReport(report);
+    await safeTrackWizardTelemetry("skills_synced", {
+      changed_count: countSkillReportChanges(report),
+      command: "skills:sync",
+      pack_count: report.packs.length,
+      plugin_managed_target_count: pluginTargets.length,
+      requested_pack_count: packs.length,
+      skill_extension_count: report.extensions.length,
       write_count: report.writes.length
     });
   });
+  skills.command("status").description("Show installed skill/rule tracking and local skill extensions.").action(async () => {
+    const report = getSkillStatus();
+    console.log(pc3.dim("  extensions"));
+    printSkillExtensions(report.extensions);
+    console.log("");
+    console.log(pc3.dim("  generated files"));
+    if (report.trackedFiles.length === 0) {
+      console.log(`  ${ICON.skip}  ${pc3.dim("no generated skill files tracked yet")}`);
+    } else {
+      for (const file of report.trackedFiles) {
+        console.log(`  ${ICON.ok}  ${pc3.bold(file.skillId.padEnd(24))} ${pc3.dim(file.path)}`);
+      }
+    }
+  });
+  const skillExtensions = skills.command("extensions").description("Create, edit, and sync user extensions appended after OrgX core skills.");
+  skillExtensions.command("list").description("List local OrgX skill extensions.").action(() => {
+    printSkillExtensions(listSkillExtensions());
+  });
+  skillExtensions.command("add").description("Create a local extension file for an OrgX skill.").argument("<skill>", "Skill id, for example orgx, cursor-rules, or morning-briefing").option("--scope <scope>", "Extension scope: user, workspace, or project.", "user").option("--title <title>", "Extension title.").option("--content <content>", "Initial extension body content.").option("--overwrite", "Overwrite an existing extension file.").action((skill, options) => {
+    const result = addSkillExtension({
+      overwrite: options.overwrite === true,
+      skillId: skill,
+      ...options.content !== void 0 ? { content: options.content } : {},
+      ...options.scope !== void 0 ? { scope: options.scope } : {},
+      ...options.title !== void 0 ? { title: options.title } : {}
+    });
+    printSkillExtensionWrite(result);
+    console.log(
+      `  ${ICON.skip}  ${pc3.dim(`Run ${getCmd()} skills sync to apply it to configured tools.`)}`
+    );
+  });
+  skillExtensions.command("edit").description("Create if needed, then open a local OrgX skill extension in $EDITOR.").argument("<skill>", "Skill id, for example orgx, cursor-rules, or morning-briefing").option("--scope <scope>", "Extension scope: user, workspace, or project.", "user").action((skill, options) => {
+    const result = addSkillExtension({
+      skillId: skill,
+      ...options.scope !== void 0 ? { scope: options.scope } : {}
+    });
+    printSkillExtensionWrite(result);
+    if (!openPathInEditor(result.path)) {
+      console.log(
+        `  ${ICON.warn}  ${pc3.yellow("editor not opened")} ${pc3.dim(`Set EDITOR or edit ${result.path}`)}`
+      );
+    }
+    console.log(
+      `  ${ICON.skip}  ${pc3.dim(`Run ${getCmd()} skills sync to apply it to configured tools.`)}`
+    );
+  });
+  skillExtensions.command("enable").description("Enable a local OrgX skill extension.").argument("<skill>", "Skill id, for example orgx, cursor-rules, or morning-briefing").option("--scope <scope>", "Extension scope: user, workspace, or project.", "user").action((skill, options) => {
+    const result = setSkillExtensionEnabled({
+      enabled: true,
+      skillId: skill,
+      ...options.scope !== void 0 ? { scope: options.scope } : {}
+    });
+    printSkillExtensionWrite(result);
+    console.log(
+      `  ${ICON.skip}  ${pc3.dim(`Run ${getCmd()} skills sync to apply it to configured tools.`)}`
+    );
+  });
+  skillExtensions.command("disable").description("Disable a local OrgX skill extension without deleting it.").argument("<skill>", "Skill id, for example orgx, cursor-rules, or morning-briefing").option("--scope <scope>", "Extension scope: user, workspace, or project.", "user").action((skill, options) => {
+    const result = setSkillExtensionEnabled({
+      enabled: false,
+      skillId: skill,
+      ...options.scope !== void 0 ? { scope: options.scope } : {}
+    });
+    printSkillExtensionWrite(result);
+    console.log(
+      `  ${ICON.skip}  ${pc3.dim(`Run ${getCmd()} skills sync to apply it to configured tools.`)}`
+    );
+  });
   await program.parseAsync(process.argv);
 }
 main().catch((error) => {