@useorgx/wizard 0.1.9 → 0.1.11

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) {
@@ -978,6 +980,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 +1025,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 +1033,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 +1055,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) {
@@ -1046,6 +1085,9 @@ function getOrCreateWizardInstallationId(statePath = ORGX_WIZARD_STATE_PATH) {
   writeWizardState(record, statePath);
   return record.installationId;
 }
+function clearWizardState(statePath = ORGX_WIZARD_STATE_PATH) {
+  return deleteFileIfExists(statePath);
+}
 
 // src/lib/agent-roster.ts
 var AGENT_ROSTER_PROFILES = [
@@ -3002,7 +3044,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",
@@ -3014,6 +3058,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.
@@ -3069,6 +3116,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("/");
 }
@@ -3134,12 +3394,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,
@@ -3204,19 +3487,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 } : {}
+        }
       )
     );
   }
@@ -3234,6 +3525,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;
@@ -3247,41 +3545,108 @@ 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
 } from "fs";
 import { tmpdir } from "os";
 import { dirname as dirname3, join as join3, relative } from "path";
-var DEFAULT_ORGX_PLUGIN_TARGETS = ["claude", "codex", "openclaw"];
+var DEFAULT_ORGX_PLUGIN_TARGETS = ["cursor", "claude", "codex", "openclaw"];
 var ORGX_PLUGIN_GITHUB_OWNER = "useorgx";
 var ORGX_PLUGIN_GITHUB_REF = "main";
 var ORGX_CLAUDE_PLUGIN_NAME = "orgx-claude-code-plugin";
@@ -3320,7 +3685,8 @@ function defaultPluginPaths() {
     claudeMarketplaceManifestPath: CLAUDE_MANAGED_MARKETPLACE_MANIFEST_PATH,
     claudePluginDir: CLAUDE_MANAGED_PLUGIN_DIR,
     codexMarketplacePath: CODEX_MARKETPLACE_PATH,
-    codexPluginDir: CODEX_ORGX_PLUGIN_DIR
+    codexPluginDir: CODEX_ORGX_PLUGIN_DIR,
+    cursorRulePath: CURSOR_ORGX_RULE_PATH
   };
 }
 function resolvePluginPaths(paths = {}) {
@@ -3339,8 +3705,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);
@@ -3450,7 +3816,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;
@@ -3474,17 +3840,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));
@@ -3497,15 +3863,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;
   }
@@ -3515,7 +3881,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;
   }
@@ -3606,7 +3972,7 @@ function upsertCodexMarketplaceEntry(path) {
   return writeJsonIfChanged(path, nextDocument);
 }
 function removeCodexMarketplaceEntry(path) {
-  if (!existsSync3(path)) {
+  if (!existsSync4(path)) {
     return false;
   }
   const { document, plugins } = readMarketplacePlugins(path);
@@ -3740,6 +4106,32 @@ async function getOpenclawInstallState(runner) {
     installed: extractOpenclawPluginIds(result.stdout).includes(ORGX_OPENCLAW_PLUGIN_ID)
   };
 }
+function buildCursorStatus(paths) {
+  const existingRules = readTextIfExists(paths.cursorRulePath);
+  const available = detectSurface("cursor").detected || existingRules !== null;
+  if (existingRules === CURSOR_RULES_CONTENT) {
+    return {
+      target: "cursor",
+      available: true,
+      installed: true,
+      message: "Cursor OrgX rules are installed."
+    };
+  }
+  if (existingRules !== null) {
+    return {
+      target: "cursor",
+      available: true,
+      installed: false,
+      message: "Cursor OrgX rules file exists, but differs from the managed rules."
+    };
+  }
+  return {
+    target: "cursor",
+    available,
+    installed: false,
+    message: available ? "Cursor is available and ready for OrgX rules install." : "Cursor was not detected."
+  };
+}
 async function buildClaudeStatus(paths, runner) {
   const state = await getClaudeInstallState(runner);
   if (state.installed) {
@@ -3758,7 +4150,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,
@@ -3769,7 +4161,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) {
@@ -3855,6 +4247,30 @@ async function resolveOpenclawTarball(fetchImpl) {
     version: latestVersion
   };
 }
+function installCursorPlugin(paths) {
+  const existingRules = readTextIfExists(paths.cursorRulePath);
+  const available = detectSurface("cursor").detected || existingRules !== null;
+  if (!available) {
+    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);
+  return {
+    target: "cursor",
+    changed: true,
+    message: "Installed the managed Cursor OrgX rules."
+  };
+}
 async function installClaudePlugin(paths, fetchImpl, runner) {
   const state = await getClaudeInstallState(runner);
   if (!state.available) {
@@ -3961,6 +4377,29 @@ async function installOpenclawPlugin(fetchImpl, runner) {
     message: `Installed OpenClaw plugin ${ORGX_OPENCLAW_PLUGIN_ID} from ${ORGX_OPENCLAW_PLUGIN_PACKAGE_NAME}@${version}.`
   };
 }
+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);
+  return {
+    target: "cursor",
+    changed,
+    message: changed ? "Removed the managed Cursor OrgX rules." : "Cursor OrgX rules were not installed."
+  };
+}
 async function uninstallClaudePlugin(paths, runner) {
   const state = await getClaudeInstallState(runner);
   let changed = false;
@@ -4056,6 +4495,7 @@ async function listOrgxPluginStatuses(options = {}) {
   const paths = resolvePluginPaths(options.paths);
   const runner = resolveCommandRunner(options.commandRunner);
   return await Promise.all([
+    buildCursorStatus(paths),
     buildClaudeStatus(paths, runner),
     buildCodexStatus(paths, runner),
     buildOpenclawStatus(runner)
@@ -4072,6 +4512,9 @@ async function installOrgxPlugins(options = {}) {
   const results = [];
   for (const target of targets) {
     switch (target) {
+      case "cursor":
+        results.push(installCursorPlugin(paths));
+        break;
       case "claude":
         results.push(await installClaudePlugin(paths, fetchImpl, runner));
         break;
@@ -4092,6 +4535,9 @@ async function uninstallOrgxPlugins(options = {}) {
   const results = [];
   for (const target of targets) {
     switch (target) {
+      case "cursor":
+        results.push(uninstallCursorPlugin(paths));
+        break;
       case "claude":
         results.push(await uninstallClaudePlugin(paths, runner));
         break;
@@ -4558,6 +5004,8 @@ function formatAuthSource(source) {
 }
 function formatPluginTargetLabel(target) {
   switch (target) {
+    case "cursor":
+      return "Cursor rules";
     case "claude":
       return "Claude Code";
     case "codex":
@@ -4602,30 +5050,79 @@ function printPluginMutationReport(report) {
     );
   }
 }
+async function printPluginStatusSection() {
+  const spinner = createOrgxSpinner("Checking OrgX plugin and Cursor rules status");
+  spinner.start();
+  const statuses = await listOrgxPluginStatuses();
+  spinner.succeed("OrgX plugin and Cursor rules status checked");
+  console.log("");
+  console.log(pc3.dim("  plugins"));
+  printPluginStatusReport(statuses);
+  return statuses;
+}
 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);
@@ -4704,8 +5201,9 @@ async function textPrompt(input) {
 }
 async function multiselectPrompt(input) {
   const promptInput = {
-    message: input.message,
+    message: `${input.message} ${pc3.dim("Space selects items; Enter continues.")}`,
     options: input.options,
+    ...input.initialValues ? { initialValues: input.initialValues } : {},
     ...input.required !== void 0 ? { required: input.required } : {}
   };
   return normalizePromptResult(await clack.multiselect(promptInput));
@@ -4854,10 +5352,11 @@ async function maybeConfigureOptionalWorkspaceAddOns(input) {
   const hasAgentRoster = refreshedState?.agentRoster?.workspaceId === input.workspace.id;
   if (!hasAgentRoster) {
     const rosterChoice = await selectPrompt({
+      initialValue: "default",
       message: `Set up an OrgX agent roster for ${input.workspace.name}?`,
       options: [
-        { value: "guided", label: "Choose agents and domains", hint: "recommended" },
-        { value: "default", label: "Install the full default roster" },
+        { value: "default", label: "Install the full default roster", hint: "recommended" },
+        { value: "guided", label: "Choose agents and domains" },
         { value: "no", label: "Skip roster setup" }
       ]
     });
@@ -4912,13 +5411,19 @@ async function promptOptionalCompanionPluginTargets(input) {
   if (!input.interactive) {
     return [];
   }
-  const statuses = await listOrgxPluginStatuses();
+  let statuses = input.statuses;
+  if (!statuses) {
+    const spinner = createOrgxSpinner("Checking optional OrgX plugin and Cursor rules status");
+    spinner.start();
+    statuses = await listOrgxPluginStatuses();
+    spinner.succeed("Optional OrgX plugin and Cursor rules 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?",
+    message: "Install OrgX companion plugins/rules into your detected AI tools?",
     options: installable.map((status) => ({
       value: status.target,
       label: `Install ${formatPluginTargetLabel(status.target)}`,
@@ -4946,10 +5451,10 @@ async function installSelectedCompanionPlugins(input) {
   if (input.targets.length === 0) {
     return "skipped";
   }
-  const spinner = createOrgxSpinner("Installing OrgX companion plugins");
+  const spinner = createOrgxSpinner("Installing OrgX companion plugins/rules");
   spinner.start();
   const report = await installOrgxPlugins({ targets: input.targets });
-  spinner.succeed("OrgX companion plugins processed");
+  spinner.succeed("OrgX companion plugins/rules processed");
   printPluginMutationReport(report);
   printPluginSkillOwnershipNote(input.targets);
   await safeTrackWizardTelemetry("plugins_installed", {
@@ -4963,7 +5468,8 @@ async function installSelectedCompanionPlugins(input) {
 }
 async function maybeInstallOptionalCompanionPlugins(input) {
   const selection = await promptOptionalCompanionPluginTargets({
-    interactive: input.interactive
+    interactive: input.interactive,
+    ...input.statuses ? { statuses: input.statuses } : {}
   });
   if (selection === "cancelled") {
     return "cancelled";
@@ -5050,13 +5556,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.9" : 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.11" : 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",
@@ -5162,6 +5668,7 @@ async function main() {
     const results = await setupDetectedSurfaces();
     spinner.succeed("Detected surfaces configured");
     printMutationResults(results);
+    const pluginStatuses = await printPluginStatusSection();
     await safeTrackWizardTelemetry("mcp_injected", {
       changed_count: results.filter((result) => result.changed).length,
       preset: "standard",
@@ -5250,6 +5757,7 @@ async function main() {
       }
       const pluginInstallResult = await maybeInstallOptionalCompanionPlugins({
         interactive,
+        statuses: pluginStatuses,
         telemetry: { command: "setup", preset: "standard" }
       });
       if (pluginInstallResult === "cancelled") {
@@ -5420,6 +5928,51 @@ async function main() {
       );
     }
   });
+  program.command("uninstall").description("Remove OrgX-managed MCP tool configs, 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 tool config removal.").action(async (options) => {
+    await safeTrackWizardTelemetry("wizard_uninstalled", {
+      keep_auth: Boolean(options.keepAuth),
+      keep_state: Boolean(options.keepState),
+      skip_plugins: Boolean(options.skipPlugins),
+      skip_surfaces: Boolean(options.skipSurfaces)
+    });
+    console.log(pc3.bold("Removing OrgX wizard-managed configuration"));
+    if (options.skipSurfaces) {
+      console.log(`  ${ICON.skip}  ${pc3.bold("surfaces".padEnd(10))} ${pc3.dim("skipped")}`);
+    } else {
+      console.log("");
+      console.log(pc3.dim("  surfaces"));
+      const surfaceResults = removeSurface(["all"]);
+      printMutationResults(surfaceResults);
+    }
+    if (options.skipPlugins) {
+      console.log(`  ${ICON.skip}  ${pc3.bold("plugins".padEnd(12))} ${pc3.dim("skipped")}`);
+    } else {
+      console.log("");
+      console.log(pc3.dim("  plugins"));
+      const spinner = createOrgxSpinner("Removing OrgX companion plugins and rules");
+      spinner.start();
+      const pluginReport = await uninstallOrgxPlugins({ targets: ["all"] });
+      spinner.succeed("OrgX companion plugins and rules processed");
+      printPluginMutationReport(pluginReport);
+    }
+    console.log("");
+    if (options.keepAuth) {
+      console.log(`  ${ICON.skip}  ${pc3.bold("auth".padEnd(12))} ${pc3.dim("kept")}`);
+    } else {
+      const removedAuth = await clearWizardAuth();
+      const state = removedAuth ? pc3.green("updated  ") : pc3.dim("unchanged");
+      const message = removedAuth ? "Removed the wizard-local OrgX API key." : "No wizard-local OrgX API key was stored.";
+      console.log(`  ${removedAuth ? ICON.ok : ICON.skip}  ${pc3.bold("auth".padEnd(12))} ${state}  ${pc3.dim(message)}`);
+    }
+    if (options.keepState) {
+      console.log(`  ${ICON.skip}  ${pc3.bold("state".padEnd(12))} ${pc3.dim("kept")}`);
+    } else {
+      const removedState = clearWizardState();
+      const state = removedState ? pc3.green("updated  ") : pc3.dim("unchanged");
+      const message = removedState ? "Removed wizard-local setup state." : "No wizard-local setup state was stored.";
+      console.log(`  ${removedState ? ICON.ok : ICON.skip}  ${pc3.bold("state".padEnd(12))} ${state}  ${pc3.dim(message)}`);
+    }
+  });
   const surface = program.command("surface").description("Manage supported OrgX surfaces.");
   surface.command("list").description("Show supported surfaces and their current status.").action(() => {
     printSurfaceTable(listSurfaceStatuses());
@@ -5432,28 +5985,28 @@ 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 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 companion plugin status");
+  const plugins = program.command("plugins").description("Install or remove OrgX companion plugins/rules in Cursor, Claude Code, Codex, and OpenClaw.");
+  plugins.command("list").description("Show companion plugin/rules availability and install status in your tools.").action(async () => {
+    const spinner = createOrgxSpinner("Checking OrgX plugin and Cursor rules status");
     spinner.start();
     const statuses = await listOrgxPluginStatuses();
-    spinner.stop();
+    spinner.succeed("OrgX plugin and Cursor rules status checked");
     printPluginStatusReport(statuses);
   });
-  plugins.command("add").description("Install OrgX companion plugins into Claude Code, Codex, or OpenClaw.").argument("[targets...]", "claude, codex, openclaw, or all", ["all"]).action(async (targets) => {
-    const spinner = createOrgxSpinner("Installing OrgX companion plugins");
+  plugins.command("add").description("Install OrgX companion plugins/rules 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/rules");
     spinner.start();
     const report = await installOrgxPlugins({ targets });
-    spinner.succeed("OrgX companion plugins processed");
+    spinner.succeed("OrgX companion plugins/rules processed");
     printPluginMutationReport(report);
     printPluginSkillOwnershipNote(report.results.map((result) => result.target));
     await safeTrackWizardTelemetry("plugins_installed", {
@@ -5463,11 +6016,11 @@ async function main() {
       target_count: report.results.length
     });
   });
-  plugins.command("remove").description("Uninstall managed OrgX companion plugins from Claude Code, Codex, or OpenClaw.").argument("[targets...]", "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/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/rules");
     spinner.start();
     const report = await uninstallOrgxPlugins({ targets });
-    spinner.succeed("OrgX companion plugins removed");
+    spinner.succeed("OrgX companion plugins/rules removed");
     printPluginMutationReport(report);
     await safeTrackWizardTelemetry("plugins_removed", {
       changed_count: countPluginReportChanges(report),
@@ -5542,16 +6095,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),
@@ -5559,9 +6113,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) => {