@useorgx/wizard 0.1.7 → 0.1.8

package/dist/cli.js

@@ -28,10 +28,25 @@ var ORGX_HOSTED_MCP_KEY = "orgx";
 var ORGX_LOCAL_MCP_KEY = "orgx-openclaw";
 var ORGX_HOSTED_MCP_URL = "https://mcp.useorgx.com/mcp";
 var ORGX_HOSTED_MCP_HEALTH_URL = "https://mcp.useorgx.com/health";
+var ORGX_HOSTED_OAUTH_BASE_URL = "https://mcp.useorgx.com";
+var ORGX_HOSTED_OAUTH_AUTHORIZE_URL = `${ORGX_HOSTED_OAUTH_BASE_URL}/authorize`;
+var ORGX_HOSTED_OAUTH_TOKEN_URL = `${ORGX_HOSTED_OAUTH_BASE_URL}/token`;
+var ORGX_HOSTED_OAUTH_REGISTER_URL = `${ORGX_HOSTED_OAUTH_BASE_URL}/register`;
 var ORGX_WIZARD_NPM_PACKAGE_NAME = "@useorgx/wizard";
 var NPM_REGISTRY_BASE_URL = "https://registry.npmjs.org";
 var DEFAULT_OPENCLAW_GATEWAY_PORT = 18789;
-var DEFAULT_ORGX_BASE_URL = process.env.ORGX_BASE_URL?.trim() || "https://www.useorgx.com";
+var DEFAULT_ORGX_BASE_URL = process.env.ORGX_BASE_URL?.trim() || "https://useorgx.com";
+var ORGX_WIZARD_OAUTH_SCOPES = [
+  "decisions:read",
+  "decisions:write",
+  "agents:read",
+  "agents:write",
+  "initiatives:read",
+  "initiatives:write",
+  "memory:read",
+  "offline_access"
+];
+var ORGX_WIZARD_OAUTH_SCOPE = ORGX_WIZARD_OAUTH_SCOPES.join(" ");
 var HOME = homedir();
 var APPDATA = process.env.APPDATA?.trim();
 var LOCAL_APPDATA = process.env.LOCALAPPDATA?.trim();
@@ -59,11 +74,31 @@ var CLAUDE_DIR = join(HOME, ".claude");
 var CURSOR_DIR = join(HOME, ".cursor");
 var CODEX_DIR = join(HOME, ".codex");
 var OPENCLAW_DIR = join(HOME, ".openclaw");
+var AGENTS_DIR = join(HOME, ".agents");
 var CLAUDE_SKILLS_DIR = join(CLAUDE_DIR, "skills");
 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 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");
+var CODEX_MARKETPLACE_PATH = join(CODEX_MARKETPLACE_DIR, "marketplace.json");
+var CLAUDE_MANAGED_MARKETPLACE_DIR = join(
+  ORGX_WIZARD_CONFIG_HOME,
+  "plugins",
+  "claude-marketplace"
+);
+var CLAUDE_MANAGED_MARKETPLACE_MANIFEST_PATH = join(
+  CLAUDE_MANAGED_MARKETPLACE_DIR,
+  ".claude-plugin",
+  "marketplace.json"
+);
+var CLAUDE_MANAGED_PLUGIN_DIR = join(
+  CLAUDE_MANAGED_MARKETPLACE_DIR,
+  "plugins",
+  "orgx-claude-code-plugin"
+);
 var CLAUDE_MCP_PATHS = uniquePaths([join(CLAUDE_DIR, "mcp.json")]);
 var CURSOR_MCP_PATHS = uniquePaths([join(CURSOR_DIR, "mcp.json")]);
 var CODEX_CONFIG_PATHS = uniquePaths([join(CODEX_DIR, "config.toml")]);
@@ -367,6 +402,19 @@ function buildStoredRecord(value) {
     verifiedAt: value.verifiedAt
   };
 }
+function readWizardAuthMetadata(authPath = ORGX_WIZARD_AUTH_PATH) {
+  const stored = parseStoredWizardAuthRecord(readTextIfExists(authPath));
+  if (!stored) {
+    return null;
+  }
+  return {
+    baseUrl: stored.baseUrl,
+    keyPrefix: stored.keyPrefix,
+    source: "manual",
+    storage: stored.storage,
+    verifiedAt: stored.verifiedAt
+  };
+}
 async function readWizardAuth(authPath = ORGX_WIZARD_AUTH_PATH, options = {}) {
   const stored = parseStoredWizardAuthRecord(readTextIfExists(authPath));
   if (!stored) {
@@ -466,7 +514,11 @@ function normalizeOrgxBaseUrl(raw) {
   }
 }
 function buildOrgxApiUrl(path, baseUrl) {
-  const normalizedBase = normalizeOrgxBaseUrl(baseUrl).replace(/\/+$/, "");
+  const parsedBase = new URL(normalizeOrgxBaseUrl(baseUrl));
+  if (parsedBase.protocol === "https:" && normalizeHost(parsedBase.hostname) === "useorgx.com") {
+    parsedBase.hostname = "www.useorgx.com";
+  }
+  const normalizedBase = parsedBase.toString().replace(/\/+$/, "");
   const apiBase = normalizedBase.endsWith("/api") ? normalizedBase : `${normalizedBase}/api`;
   const normalizedPath = path.startsWith("/") ? path : `/${path}`;
   return `${apiBase}${normalizedPath}`;
@@ -484,6 +536,52 @@ function buildResolvedAuth(apiKey, baseUrl, source, extras = {}) {
     ...extras.verifiedAt ? { verifiedAt: extras.verifiedAt } : {}
   };
 }
+function buildAuthHint(keyPrefix, baseUrl, source, extras = {}) {
+  return {
+    keyPrefix: keyPrefix.trim(),
+    baseUrl,
+    source,
+    ...extras.path ? { path: extras.path } : {},
+    ...extras.verifiedAt ? { verifiedAt: extras.verifiedAt } : {}
+  };
+}
+function peekResolvedOrgxAuth(options = {}) {
+  const envApiKey = process.env.ORGX_API_KEY?.trim();
+  const envBaseUrl = process.env.ORGX_BASE_URL?.trim();
+  if (envApiKey) {
+    return buildAuthHint(
+      extractKeyPrefix(envApiKey),
+      withResolvedBaseUrl(DEFAULT_ORGX_BASE_URL, envBaseUrl),
+      "environment"
+    );
+  }
+  const authPath = options.authPath ?? ORGX_WIZARD_AUTH_PATH;
+  const stored = readWizardAuthMetadata(authPath);
+  if (stored) {
+    return buildAuthHint(
+      stored.keyPrefix,
+      withResolvedBaseUrl(stored.baseUrl, envBaseUrl),
+      "wizard-store",
+      {
+        path: authPath,
+        verifiedAt: stored.verifiedAt
+      }
+    );
+  }
+  const openclawConfigPath = options.openclawConfigPath ?? OPENCLAW_CONFIG_PATH;
+  const openclawAuth = readOpenClawAuth(
+    openclawConfigPath ? readTextIfExists(openclawConfigPath) : null
+  );
+  if (openclawAuth.apiKey && openclawConfigPath) {
+    return buildAuthHint(
+      extractKeyPrefix(openclawAuth.apiKey),
+      withResolvedBaseUrl(openclawAuth.baseUrl || DEFAULT_ORGX_BASE_URL, envBaseUrl),
+      "openclaw-config-file",
+      { path: openclawConfigPath }
+    );
+  }
+  return null;
+}
 async function resolveOrgxAuth(options = {}) {
   const envApiKey = process.env.ORGX_API_KEY?.trim();
   const envBaseUrl = process.env.ORGX_BASE_URL?.trim();
@@ -745,6 +843,295 @@ function openBrowser(url) {
   return { ok: true };
 }
 
+// src/lib/wizard-state.ts
+import { randomUUID } from "crypto";
+
+// src/surfaces/names.ts
+var SURFACE_NAMES = [
+  "claude",
+  "cursor",
+  "codex",
+  "openclaw",
+  "vscode",
+  "windsurf",
+  "zed",
+  "chatgpt"
+];
+var AUTOMATED_SURFACE_NAMES = [
+  "claude",
+  "cursor",
+  "codex",
+  "openclaw",
+  "vscode",
+  "windsurf",
+  "zed"
+];
+var MCP_SURFACE_NAMES = [
+  "claude",
+  "cursor",
+  "codex",
+  "vscode",
+  "windsurf",
+  "zed"
+];
+
+// src/lib/wizard-state.ts
+function isNonEmptyString2(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function isSurfaceName(value) {
+  return typeof value === "string" && SURFACE_NAMES.includes(value);
+}
+function parseContinuityDefaults(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return void 0;
+  }
+  const record = value;
+  const parsed = {};
+  if (record.executionMode === "cloud" || record.executionMode === "local") {
+    parsed.executionMode = record.executionMode;
+  }
+  if (isSurfaceName(record.reviewSurface)) {
+    parsed.reviewSurface = record.reviewSurface;
+  }
+  if (isNonEmptyString2(record.workspaceId)) {
+    parsed.workspaceId = record.workspaceId.trim();
+  }
+  if (isNonEmptyString2(record.workspaceName)) {
+    parsed.workspaceName = record.workspaceName.trim();
+  }
+  return Object.keys(parsed).length > 0 ? parsed : void 0;
+}
+function parseDemoInitiative(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return void 0;
+  }
+  const record = value;
+  if (!isNonEmptyString2(record.id) || !isNonEmptyString2(record.title) || !isNonEmptyString2(record.liveUrl) || !isNonEmptyString2(record.createdAt)) {
+    return void 0;
+  }
+  return {
+    createdAt: record.createdAt.trim(),
+    ...isNonEmptyString2(record.artifactId) ? { artifactId: record.artifactId.trim() } : {},
+    ...isNonEmptyString2(record.artifactName) ? { artifactName: record.artifactName.trim() } : {},
+    ...isNonEmptyString2(record.artifactType) ? { artifactType: record.artifactType.trim() } : {},
+    ...isNonEmptyString2(record.artifactUrl) ? { artifactUrl: record.artifactUrl.trim() } : {},
+    ...isNonEmptyString2(record.decisionId) ? { decisionId: record.decisionId.trim() } : {},
+    ...isNonEmptyString2(record.decisionStatus) ? { decisionStatus: record.decisionStatus.trim() } : {},
+    ...isNonEmptyString2(record.decisionTitle) ? { decisionTitle: record.decisionTitle.trim() } : {},
+    id: record.id.trim(),
+    liveUrl: record.liveUrl.trim(),
+    title: record.title.trim(),
+    ...isNonEmptyString2(record.workspaceId) ? { workspaceId: record.workspaceId.trim() } : {},
+    ...isNonEmptyString2(record.workspaceName) ? { workspaceName: record.workspaceName.trim() } : {}
+  };
+}
+function parseOnboardingTask(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return void 0;
+  }
+  const record = value;
+  if (!isNonEmptyString2(record.id) || !isNonEmptyString2(record.title) || !isNonEmptyString2(record.createdAt)) {
+    return void 0;
+  }
+  return {
+    createdAt: record.createdAt.trim(),
+    id: record.id.trim(),
+    ...isNonEmptyString2(record.initiativeId) ? { initiativeId: record.initiativeId.trim() } : {},
+    ...isNonEmptyString2(record.status) ? { status: record.status.trim() } : {},
+    title: record.title.trim(),
+    ...isNonEmptyString2(record.workspaceId) ? { workspaceId: record.workspaceId.trim() } : {},
+    ...isNonEmptyString2(record.workspaceName) ? { workspaceName: record.workspaceName.trim() } : {}
+  };
+}
+function parseAgentRosterEntry(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return void 0;
+  }
+  const record = value;
+  if (!isNonEmptyString2(record.agentType) || !isNonEmptyString2(record.domain) || !isNonEmptyString2(record.name)) {
+    return void 0;
+  }
+  return {
+    agentType: record.agentType.trim(),
+    domain: record.domain.trim(),
+    name: record.name.trim()
+  };
+}
+function parseAgentRoster(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return void 0;
+  }
+  const record = value;
+  if (!isNonEmptyString2(record.configuredAt) || !Array.isArray(record.agents)) {
+    return void 0;
+  }
+  const agents = record.agents.map((entry) => parseAgentRosterEntry(entry)).filter((entry) => Boolean(entry));
+  if (agents.length === 0) {
+    return void 0;
+  }
+  return {
+    agents,
+    configuredAt: record.configuredAt.trim(),
+    ...isNonEmptyString2(record.workspaceId) ? { workspaceId: record.workspaceId.trim() } : {},
+    ...isNonEmptyString2(record.workspaceName) ? { workspaceName: record.workspaceName.trim() } : {}
+  };
+}
+function createWizardState(now = (/* @__PURE__ */ new Date()).toISOString()) {
+  return {
+    installationId: `wizard-${randomUUID()}`,
+    createdAt: now,
+    updatedAt: now
+  };
+}
+function sanitizeWizardStateRecord(record) {
+  const continuity = parseContinuityDefaults(record.continuity);
+  const agentRoster = parseAgentRoster(record.agentRoster);
+  const demoInitiative = parseDemoInitiative(record.demoInitiative);
+  const onboardingTask = parseOnboardingTask(record.onboardingTask);
+  return {
+    installationId: record.installationId.trim(),
+    createdAt: record.createdAt.trim(),
+    updatedAt: record.updatedAt.trim(),
+    ...continuity ? { continuity } : {},
+    ...agentRoster ? { agentRoster } : {},
+    ...demoInitiative ? { demoInitiative } : {},
+    ...onboardingTask ? { onboardingTask } : {}
+  };
+}
+function readWizardState(statePath = ORGX_WIZARD_STATE_PATH) {
+  const parsed = parseJsonObject(readTextIfExists(statePath));
+  if (!isNonEmptyString2(parsed.installationId) || !isNonEmptyString2(parsed.createdAt) || !isNonEmptyString2(parsed.updatedAt)) {
+    return null;
+  }
+  const state = {
+    installationId: parsed.installationId.trim(),
+    createdAt: parsed.createdAt.trim(),
+    updatedAt: parsed.updatedAt.trim()
+  };
+  const continuity = parseContinuityDefaults(parsed.continuity);
+  if (continuity !== void 0) state.continuity = continuity;
+  const agentRoster = parseAgentRoster(parsed.agentRoster);
+  if (agentRoster !== void 0) state.agentRoster = agentRoster;
+  const demoInitiative = parseDemoInitiative(parsed.demoInitiative);
+  if (demoInitiative !== void 0) state.demoInitiative = demoInitiative;
+  const onboardingTask = parseOnboardingTask(parsed.onboardingTask);
+  if (onboardingTask !== void 0) state.onboardingTask = onboardingTask;
+  return state;
+}
+function writeWizardState(value, statePath = ORGX_WIZARD_STATE_PATH) {
+  const record = sanitizeWizardStateRecord(value);
+  writeJsonFile(statePath, record, { mode: 384 });
+  return record;
+}
+function updateWizardState(updater, statePath = ORGX_WIZARD_STATE_PATH) {
+  const current = readWizardState(statePath) ?? createWizardState();
+  const next = updater(current);
+  const sanitized = sanitizeWizardStateRecord({
+    ...next,
+    installationId: next.installationId || current.installationId,
+    createdAt: next.createdAt || current.createdAt,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  writeJsonFile(statePath, sanitized, { mode: 384 });
+  return sanitized;
+}
+function getOrCreateWizardInstallationId(statePath = ORGX_WIZARD_STATE_PATH) {
+  const existing = readWizardState(statePath);
+  if (existing) {
+    return existing.installationId;
+  }
+  const record = createWizardState();
+  writeWizardState(record, statePath);
+  return record.installationId;
+}
+
+// src/lib/agent-roster.ts
+var AGENT_ROSTER_PROFILES = [
+  { agentType: "orchestrator-agent", defaultDomain: "orchestrator", name: "Xandy" },
+  { agentType: "product-agent", defaultDomain: "product", name: "Pace" },
+  { agentType: "engineering-agent", defaultDomain: "engineering", name: "Eli" },
+  { agentType: "marketing-agent", defaultDomain: "marketing", name: "Mark" },
+  { agentType: "sales-agent", defaultDomain: "sales", name: "Sage" },
+  { agentType: "operations-agent", defaultDomain: "operations", name: "Orion" },
+  { agentType: "design-agent", defaultDomain: "design", name: "Dana" }
+];
+var AGENT_ROSTER_DOMAINS = AGENT_ROSTER_PROFILES.map((profile) => profile.defaultDomain);
+var DEFAULT_AGENT_ROSTER = AGENT_ROSTER_PROFILES.map(
+  ({ agentType, defaultDomain, name }) => ({
+    agentType,
+    domain: defaultDomain,
+    name
+  })
+);
+function findAgentRosterProfile(name) {
+  return AGENT_ROSTER_PROFILES.find((profile) => profile.name === name);
+}
+function listAgentRosterProfiles() {
+  return AGENT_ROSTER_PROFILES.map((profile) => ({ ...profile }));
+}
+function buildAgentRosterEntries(assignments) {
+  const seenNames = /* @__PURE__ */ new Set();
+  return assignments.map((assignment) => {
+    const name = assignment.name.trim();
+    const domain = assignment.domain.trim();
+    if (domain.length === 0) {
+      throw new Error("OrgX agent roster domains must be non-empty.");
+    }
+    const profile = findAgentRosterProfile(name);
+    if (!profile) {
+      throw new Error(`Unknown OrgX agent '${assignment.name}'.`);
+    }
+    if (seenNames.has(profile.name)) {
+      throw new Error(`OrgX agent '${profile.name}' can only be assigned once.`);
+    }
+    seenNames.add(profile.name);
+    return {
+      agentType: profile.agentType,
+      domain,
+      name: profile.name
+    };
+  });
+}
+function toAgentRosterRecord(workspace, agents) {
+  return {
+    agents: agents.map((agent) => ({ ...agent })),
+    configuredAt: (/* @__PURE__ */ new Date()).toISOString(),
+    workspaceId: workspace.id,
+    workspaceName: workspace.name
+  };
+}
+function configureAgentRoster(workspace, assignments, options = {}) {
+  const agents = buildAgentRosterEntries(assignments);
+  if (agents.length === 0) {
+    throw new Error("Select at least one OrgX agent before saving the roster.");
+  }
+  const roster = toAgentRosterRecord(workspace, agents);
+  updateWizardState(
+    (current) => ({
+      ...current,
+      agentRoster: roster
+    }),
+    options.statePath
+  );
+  return roster;
+}
+function ensureDefaultAgentRoster(workspace, options = {}) {
+  const existing = readWizardState(options.statePath)?.agentRoster;
+  if (existing?.workspaceId === workspace.id && existing.agents.length > 0) {
+    return existing;
+  }
+  const roster = toAgentRosterRecord(workspace, DEFAULT_AGENT_ROSTER);
+  updateWizardState(
+    (current) => ({
+      ...current,
+      agentRoster: roster
+    }),
+    options.statePath
+  );
+  return roster;
+}
+
 // src/lib/openclaw-health.ts
 import { spawnSync as spawnSync2 } from "child_process";
 function trimOutput(value) {
@@ -1714,35 +2101,6 @@ function inspectCodexConfigToml(input) {
   };
 }
 
-// src/surfaces/names.ts
-var SURFACE_NAMES = [
-  "claude",
-  "cursor",
-  "codex",
-  "openclaw",
-  "vscode",
-  "windsurf",
-  "zed",
-  "chatgpt"
-];
-var AUTOMATED_SURFACE_NAMES = [
-  "claude",
-  "cursor",
-  "codex",
-  "openclaw",
-  "vscode",
-  "windsurf",
-  "zed"
-];
-var MCP_SURFACE_NAMES = [
-  "claude",
-  "cursor",
-  "codex",
-  "vscode",
-  "windsurf",
-  "zed"
-];
-
 // src/surfaces/detection.ts
 import { existsSync as existsSync2 } from "fs";
 import { dirname as dirname2 } from "path";
@@ -1823,6 +2181,9 @@ function detectSurface(name, exists = existsSync2) {
 }
 
 // src/surfaces/registry.ts
+var AUTH_SETUP_HINT = "orgx-wizard auth login";
+var AUTH_SET_KEY_HINT = "orgx-wizard auth set-key";
+var DOCTOR_HINT = "orgx-wizard doctor";
 function getSurfacePath(name) {
   const detection = detectSurface(name);
   const locator = getSurfaceLocator(name);
@@ -1951,27 +2312,92 @@ function automatedSurfaceStatus(name) {
     summary: inspection.configured ? `OpenClaw plugin entry ${inspection.pluginKey ?? "missing"} is configured.` : inspection.installed ? "OpenClaw is installed but OrgX defaults have not been written." : detection.detected ? "OpenClaw support files exist but no OrgX plugin entry was found." : "OpenClaw is not installed or no support files were found."
   };
 }
-function manualSurfaceStatus(name) {
-  const detection = detectSurface(name);
+function formatAuthHintSource(authHint) {
+  switch (authHint.source) {
+    case "environment":
+      return "env ORGX_API_KEY";
+    case "wizard-store":
+      return "wizard auth store";
+    case "openclaw-config-file":
+      return "openclaw config";
+  }
+}
+function buildChatgptManualStatus(detection, authHint) {
   const path = detection.existingPath ?? detection.preferredPath;
-  const shared = {
-    name,
+  const details = [...detection.evidence];
+  if (authHint) {
+    details.push(
+      `OrgX auth ready via ${formatAuthHintSource(authHint)} (${authHint.keyPrefix})`
+    );
+    details.push(`Hosted connector URL: ${ORGX_HOSTED_MCP_URL}`);
+    details.push(
+      "Manual step: in ChatGPT desktop developer mode, add a custom connector pointing at the hosted OrgX MCP URL."
+    );
+    details.push(
+      "After connecting ChatGPT, run `orgx-wizard doctor` to verify hosted MCP tool access."
+    );
+  } else {
+    details.push(
+      "OrgX auth is not configured yet. Run `orgx-wizard auth login` or `orgx-wizard auth set-key` first."
+    );
+    details.push(
+      "After auth is configured, add a custom ChatGPT developer connector pointing at the hosted OrgX MCP URL."
+    );
+  }
+  let summary;
+  if (!authHint) {
+    summary = detection.detected ? "ChatGPT is installed, but OrgX auth is not configured yet." : "ChatGPT support files were not found; configure OrgX auth first, then add the hosted connector manually.";
+  } else {
+    summary = detection.detected ? "ChatGPT is installed; finish the manual developer connector setup." : "OrgX auth is ready, but ChatGPT desktop support files were not found on disk.";
+  }
+  return {
+    name: "chatgpt",
     mode: "manual",
     detected: detection.detected,
     configured: false,
-    ...path ? { path } : {}
+    ...path ? { path } : {},
+    details,
+    summary
+  };
+}
+function buildChatgptAddResult(path, authHint, toolCheck) {
+  if (!authHint) {
+    return {
+      name: "chatgpt",
+      changed: false,
+      ...path ? { path } : {},
+      message: `Run \`${AUTH_SETUP_HINT}\` or \`${AUTH_SET_KEY_HINT}\` first, then add ${ORGX_HOSTED_MCP_URL} as a custom connector in ChatGPT developer mode.`
+    };
+  }
+  if (!toolCheck || !toolCheck.ok) {
+    const failure = toolCheck?.error ?? "hosted MCP verification did not complete.";
+    return {
+      name: "chatgpt",
+      changed: false,
+      ...path ? { path } : {},
+      message: `OrgX auth is configured via ${formatAuthHintSource(authHint)}, but hosted MCP verification failed (${failure}). Fix that first, then add ${ORGX_HOSTED_MCP_URL} in ChatGPT developer mode.`
+    };
+  }
+  return {
+    name: "chatgpt",
+    changed: false,
+    ...path ? { path } : {},
+    message: `OrgX auth and hosted MCP access are verified. Add ${ORGX_HOSTED_MCP_URL} as a custom connector in ChatGPT developer mode, then run \`${DOCTOR_HINT}\` to confirm \`${toolCheck.toolName}\`.`
+  };
+}
+function buildChatgptRemoveResult(path) {
+  return {
+    name: "chatgpt",
+    changed: false,
+    ...path ? { path } : {},
+    message: "Remove the custom OrgX connector from ChatGPT developer mode; the wizard does not manage ChatGPT config files directly."
   };
+}
+function manualSurfaceStatus(name) {
+  const detection = detectSurface(name);
   switch (name) {
     case "chatgpt":
-      return {
-        ...shared,
-        details: [
-          ...detection.evidence,
-          "ChatGPT desktop support is not automated yet.",
-          "Manual follow-up: wire the OrgX surface once the app-side config contract is finalized."
-        ],
-        summary: detection.detected ? "ChatGPT support files detected; manual OrgX wiring still required." : "ChatGPT desktop support files were not found on disk."
-      };
+      return buildChatgptManualStatus(detection, peekResolvedOrgxAuth());
   }
 }
 function getSurfaceStatus(name) {
@@ -2089,11 +2515,19 @@ async function addAutomatedSurface(name) {
       writeTextFile(path, next);
       return { name, changed: true, path, message: "OrgX cloud MCP is connected in Zed." };
     }
+    case "chatgpt": {
+      const authHint = peekResolvedOrgxAuth();
+      if (!authHint) {
+        return buildChatgptAddResult(path, null);
+      }
+      const toolCheck = await checkHostedMcpToolAccess();
+      return buildChatgptAddResult(path, authHint, toolCheck);
+    }
     default:
       return {
         name,
         changed: false,
-        message: `${name} is not automated yet.`
+        message: `${name} is not supported by the wizard.`
       };
   }
 }
@@ -2184,11 +2618,13 @@ function removeAutomatedSurface(name) {
         message: "OrgX connection was removed from Zed."
       };
     }
+    case "chatgpt":
+      return buildChatgptRemoveResult(path);
     default:
       return {
         name,
         changed: false,
-        message: `${name} is not automated yet.`
+        message: `${name} is not supported by the wizard.`
       };
   }
 }
@@ -2305,112 +2741,6 @@ function assessDoctorReport(report) {
   };
 }
 
-// src/lib/wizard-state.ts
-import { randomUUID } from "crypto";
-function isNonEmptyString2(value) {
-  return typeof value === "string" && value.trim().length > 0;
-}
-function isSurfaceName(value) {
-  return typeof value === "string" && SURFACE_NAMES.includes(value);
-}
-function parseContinuityDefaults(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    return void 0;
-  }
-  const record = value;
-  const parsed = {};
-  if (record.executionMode === "cloud" || record.executionMode === "local") {
-    parsed.executionMode = record.executionMode;
-  }
-  if (isSurfaceName(record.reviewSurface)) {
-    parsed.reviewSurface = record.reviewSurface;
-  }
-  if (isNonEmptyString2(record.workspaceId)) {
-    parsed.workspaceId = record.workspaceId.trim();
-  }
-  if (isNonEmptyString2(record.workspaceName)) {
-    parsed.workspaceName = record.workspaceName.trim();
-  }
-  return Object.keys(parsed).length > 0 ? parsed : void 0;
-}
-function parseDemoInitiative(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    return void 0;
-  }
-  const record = value;
-  if (!isNonEmptyString2(record.id) || !isNonEmptyString2(record.title) || !isNonEmptyString2(record.liveUrl) || !isNonEmptyString2(record.createdAt)) {
-    return void 0;
-  }
-  return {
-    createdAt: record.createdAt.trim(),
-    id: record.id.trim(),
-    liveUrl: record.liveUrl.trim(),
-    title: record.title.trim(),
-    ...isNonEmptyString2(record.workspaceId) ? { workspaceId: record.workspaceId.trim() } : {},
-    ...isNonEmptyString2(record.workspaceName) ? { workspaceName: record.workspaceName.trim() } : {}
-  };
-}
-function createWizardState(now = (/* @__PURE__ */ new Date()).toISOString()) {
-  return {
-    installationId: `wizard-${randomUUID()}`,
-    createdAt: now,
-    updatedAt: now
-  };
-}
-function sanitizeWizardStateRecord(record) {
-  const continuity = parseContinuityDefaults(record.continuity);
-  const demoInitiative = parseDemoInitiative(record.demoInitiative);
-  return {
-    installationId: record.installationId.trim(),
-    createdAt: record.createdAt.trim(),
-    updatedAt: record.updatedAt.trim(),
-    ...continuity ? { continuity } : {},
-    ...demoInitiative ? { demoInitiative } : {}
-  };
-}
-function readWizardState(statePath = ORGX_WIZARD_STATE_PATH) {
-  const parsed = parseJsonObject(readTextIfExists(statePath));
-  if (!isNonEmptyString2(parsed.installationId) || !isNonEmptyString2(parsed.createdAt) || !isNonEmptyString2(parsed.updatedAt)) {
-    return null;
-  }
-  const state = {
-    installationId: parsed.installationId.trim(),
-    createdAt: parsed.createdAt.trim(),
-    updatedAt: parsed.updatedAt.trim()
-  };
-  const continuity = parseContinuityDefaults(parsed.continuity);
-  if (continuity !== void 0) state.continuity = continuity;
-  const demoInitiative = parseDemoInitiative(parsed.demoInitiative);
-  if (demoInitiative !== void 0) state.demoInitiative = demoInitiative;
-  return state;
-}
-function writeWizardState(value, statePath = ORGX_WIZARD_STATE_PATH) {
-  const record = sanitizeWizardStateRecord(value);
-  writeJsonFile(statePath, record, { mode: 384 });
-  return record;
-}
-function updateWizardState(updater, statePath = ORGX_WIZARD_STATE_PATH) {
-  const current = readWizardState(statePath) ?? createWizardState();
-  const next = updater(current);
-  const sanitized = sanitizeWizardStateRecord({
-    ...next,
-    installationId: next.installationId || current.installationId,
-    createdAt: next.createdAt || current.createdAt,
-    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-  });
-  writeJsonFile(statePath, sanitized, { mode: 384 });
-  return sanitized;
-}
-function getOrCreateWizardInstallationId(statePath = ORGX_WIZARD_STATE_PATH) {
-  const existing = readWizardState(statePath);
-  if (existing) {
-    return existing.installationId;
-  }
-  const record = createWizardState();
-  writeWizardState(record, statePath);
-  return record.installationId;
-}
-
 // src/lib/continuity.ts
 var REVIEW_SURFACE_ORDER = [
   "claude",
@@ -2489,6 +2819,14 @@ function persistContinuityDefaults(seed = {}, statePath) {
 // src/lib/initiatives.ts
 var FOUNDER_DEMO_INITIATIVE_TITLE = "Founder Demo Initiative";
 var FOUNDER_DEMO_INITIATIVE_SUMMARY = "Starter initiative created by @useorgx/wizard to validate workspace routing, live views, and the default OrgX skill pack.";
+var FOUNDER_DEMO_DECISION_TITLE = "Approve founder demo workspace";
+var FOUNDER_DEMO_DECISION_SUMMARY = "Initial decision created by @useorgx/wizard so the founder preset leaves the workspace with a resolved approval trail.";
+var FOUNDER_DEMO_DECISION_RESOLUTION = "Approved automatically by @useorgx/wizard after the founder preset finished creating the live demo workspace.";
+var FOUNDER_DEMO_ARTIFACT_NAME = "Founder Demo Live View";
+var FOUNDER_DEMO_ARTIFACT_TYPE = "document";
+var FOUNDER_DEMO_ARTIFACT_DESCRIPTION = "Live founder demo generated by @useorgx/wizard after workspace bootstrap completed.";
+var ONBOARDING_TASK_TITLE = "Complete OrgX onboarding";
+var ONBOARDING_TASK_SUMMARY = "Starter onboarding task created by @useorgx/wizard so the first workspace has a clear follow-up after setup.";
 function parseResponseBody3(text2) {
   if (!text2) {
     return null;
@@ -2508,11 +2846,15 @@ function formatHttpError2(status, body) {
   }
   return `HTTP ${status}`;
 }
-function parseInitiative(payload) {
+function extractEntity(payload) {
   const entity = isRecord(payload) && isRecord(payload.data) ? payload.data : payload;
   if (!isRecord(entity)) {
-    throw new Error("OrgX returned an unexpected initiative payload.");
+    throw new Error("OrgX returned an unexpected entity payload.");
   }
+  return entity;
+}
+function parseInitiative(payload) {
+  const entity = extractEntity(payload);
   const id = typeof entity.id === "string" ? entity.id.trim() : "";
   const title = typeof entity.title === "string" ? entity.title.trim() : typeof entity.name === "string" ? entity.name.trim() : "";
   if (!id || !title) {
@@ -2524,9 +2866,60 @@ function parseInitiative(payload) {
     ...typeof entity.summary === "string" && entity.summary.trim().length > 0 ? { summary: entity.summary.trim() } : {}
   };
 }
-function toDemoInitiativeRecord(initiative, liveUrl, workspace) {
+function parseDecision(payload) {
+  const entity = extractEntity(payload);
+  const id = typeof entity.id === "string" ? entity.id.trim() : "";
+  const title = typeof entity.title === "string" ? entity.title.trim() : typeof entity.name === "string" ? entity.name.trim() : "";
+  if (!id || !title) {
+    throw new Error("OrgX returned an incomplete decision payload.");
+  }
+  return {
+    id,
+    title,
+    ...typeof entity.status === "string" && entity.status.trim().length > 0 ? { status: entity.status.trim() } : {},
+    ...typeof entity.summary === "string" && entity.summary.trim().length > 0 ? { summary: entity.summary.trim() } : {}
+  };
+}
+function parseArtifact(payload) {
+  const entity = extractEntity(payload);
+  const id = typeof entity.id === "string" ? entity.id.trim() : "";
+  const name = typeof entity.name === "string" ? entity.name.trim() : typeof entity.title === "string" ? entity.title.trim() : "";
+  const type = typeof entity.artifact_type === "string" ? entity.artifact_type.trim() : typeof entity.type === "string" ? entity.type.trim() : "";
+  const url = typeof entity.external_url === "string" ? entity.external_url.trim() : typeof entity.url === "string" ? entity.url.trim() : "";
+  if (!id || !name) {
+    throw new Error("OrgX returned an incomplete artifact payload.");
+  }
+  return {
+    id,
+    name,
+    ...type ? { type } : {},
+    ...url ? { url } : {}
+  };
+}
+function parseTask(payload) {
+  const entity = extractEntity(payload);
+  const id = typeof entity.id === "string" ? entity.id.trim() : "";
+  const title = typeof entity.title === "string" ? entity.title.trim() : typeof entity.name === "string" ? entity.name.trim() : "";
+  if (!id || !title) {
+    throw new Error("OrgX returned an incomplete task payload.");
+  }
+  return {
+    id,
+    title,
+    ...typeof entity.status === "string" && entity.status.trim().length > 0 ? { status: entity.status.trim() } : {},
+    ...typeof entity.summary === "string" && entity.summary.trim().length > 0 ? { summary: entity.summary.trim() } : {}
+  };
+}
+function toDemoInitiativeRecord(artifact, decision, initiative, liveUrl, workspace) {
   return {
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    artifactId: artifact.id,
+    artifactName: artifact.name,
+    ...artifact.type ? { artifactType: artifact.type } : {},
+    ...artifact.url ? { artifactUrl: artifact.url } : {},
+    decisionId: decision.id,
+    ...decision.status ? { decisionStatus: decision.status } : {},
+    decisionTitle: decision.title,
     id: initiative.id,
     liveUrl,
     title: initiative.title,
@@ -2534,6 +2927,17 @@ function toDemoInitiativeRecord(initiative, liveUrl, workspace) {
     workspaceName: workspace.name
   };
 }
+function toOnboardingTaskRecord(task, workspace, initiativeId) {
+  return {
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    id: task.id,
+    ...initiativeId ? { initiativeId } : {},
+    ...task.status ? { status: task.status } : {},
+    title: task.title,
+    workspaceId: workspace.id,
+    workspaceName: workspace.name
+  };
+}
 async function requireOrgxAuth2(options = {}) {
   const auth = await resolveOrgxAuth(options);
   if (!auth) {
@@ -2543,11 +2947,7 @@ async function requireOrgxAuth2(options = {}) {
   }
   return auth;
 }
-async function createInitiative(input, options = {}) {
-  const title = input.title.trim();
-  if (!title) {
-    throw new Error("Initiative title is required.");
-  }
+async function createEntity(type, body, parse2, options = {}) {
   const auth = await requireOrgxAuth2(options);
   const response = await fetch(buildOrgxApiUrl("/entities", auth.baseUrl), {
     method: "POST",
@@ -2556,56 +2956,183 @@ async function createInitiative(input, options = {}) {
       "Content-Type": "application/json"
     },
     body: JSON.stringify({
-      type: "initiative",
-      title,
-      status: "active",
-      ...input.summary?.trim() ? { summary: input.summary.trim() } : {},
-      ...input.workspaceId?.trim() ? { workspace_id: input.workspaceId.trim() } : {}
+      type,
+      ...body
     }),
     signal: AbortSignal.timeout(7e3)
   });
-  const body = parseResponseBody3(await response.text());
+  const responseBody = parseResponseBody3(await response.text());
   if (!response.ok) {
-    throw new Error(`Failed to create initiative. ${formatHttpError2(response.status, body)}`);
+    throw new Error(`Failed to create ${type}. ${formatHttpError2(response.status, responseBody)}`);
   }
-  return parseInitiative(body);
+  return parse2(responseBody);
 }
-async function ensureFounderDemoInitiative(workspace, options = {}) {
-  const existingRecord = readWizardState(options.statePath)?.demoInitiative;
-  if (existingRecord?.workspaceId === workspace.id) {
-    return {
-      created: false,
-      initiative: {
-        id: existingRecord.id,
-        title: existingRecord.title
-      },
-      liveUrl: existingRecord.liveUrl
-    };
-  }
+async function updateEntity(type, id, body, parse2, options = {}) {
   const auth = await requireOrgxAuth2(options);
-  const initiative = await createInitiative(
+  const response = await fetch(buildOrgxApiUrl("/entities", auth.baseUrl), {
+    method: "PATCH",
+    headers: {
+      Authorization: `Bearer ${auth.apiKey}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      type,
+      id,
+      ...body
+    }),
+    signal: AbortSignal.timeout(7e3)
+  });
+  const responseBody = parseResponseBody3(await response.text());
+  if (!response.ok) {
+    throw new Error(`Failed to update ${type}. ${formatHttpError2(response.status, responseBody)}`);
+  }
+  return parse2(responseBody);
+}
+function buildLiveUrl(baseUrl, initiativeId) {
+  const parsed = new URL(normalizeOrgxBaseUrl(baseUrl));
+  if (parsed.protocol === "https:" && parsed.hostname === "useorgx.com") {
+    parsed.hostname = "www.useorgx.com";
+  }
+  parsed.pathname = `/live/${initiativeId}`;
+  parsed.search = "";
+  parsed.hash = "";
+  return parsed.toString();
+}
+async function createFounderDemoDecision(initiative, workspaceId, options = {}) {
+  return createEntity(
+    "decision",
     {
-      title: FOUNDER_DEMO_INITIATIVE_TITLE,
-      summary: FOUNDER_DEMO_INITIATIVE_SUMMARY,
-      workspaceId: workspace.id
+      initiative_id: initiative.id,
+      summary: FOUNDER_DEMO_DECISION_SUMMARY,
+      title: FOUNDER_DEMO_DECISION_TITLE,
+      workspace_id: workspaceId
     },
+    parseDecision,
     options
   );
-  const liveUrl = `${auth.baseUrl.replace(/\/+$/, "")}/live/${initiative.id}`;
-  const record = toDemoInitiativeRecord(initiative, liveUrl, workspace);
-  updateWizardState(
-    (current) => ({
-      ...current,
-      demoInitiative: record
-    }),
-    options.statePath
+}
+async function approveFounderDemoDecision(decisionId, options = {}) {
+  return updateEntity(
+    "decision",
+    decisionId,
+    {
+      resolution_summary: FOUNDER_DEMO_DECISION_RESOLUTION,
+      status: "approved"
+    },
+    parseDecision,
+    options
+  );
+}
+async function createFounderDemoArtifact(initiative, liveUrl, workspaceId, options = {}) {
+  return createEntity(
+    "artifact",
+    {
+      artifact_type: FOUNDER_DEMO_ARTIFACT_TYPE,
+      description: FOUNDER_DEMO_ARTIFACT_DESCRIPTION,
+      entity_id: initiative.id,
+      entity_type: "initiative",
+      external_url: liveUrl,
+      initiative_id: initiative.id,
+      name: FOUNDER_DEMO_ARTIFACT_NAME,
+      workspace_id: workspaceId
+    },
+    parseArtifact,
+    options
+  );
+}
+async function createInitiative(input, options = {}) {
+  const title = input.title.trim();
+  if (!title) {
+    throw new Error("Initiative title is required.");
+  }
+  return createEntity(
+    "initiative",
+    {
+      title,
+      status: "active",
+      ...input.summary?.trim() ? { summary: input.summary.trim() } : {},
+      ...input.workspaceId?.trim() ? { workspace_id: input.workspaceId.trim() } : {}
+    },
+    parseInitiative,
+    options
+  );
+}
+async function ensureFounderDemoInitiative(workspace, options = {}) {
+  const existingRecord = readWizardState(options.statePath)?.demoInitiative;
+  const matchingRecord = existingRecord?.workspaceId === workspace.id ? existingRecord : void 0;
+  const auth = await requireOrgxAuth2(options);
+  const initiative = matchingRecord ? {
+    id: matchingRecord.id,
+    title: matchingRecord.title
+  } : await createInitiative(
+    {
+      title: FOUNDER_DEMO_INITIATIVE_TITLE,
+      summary: FOUNDER_DEMO_INITIATIVE_SUMMARY,
+      workspaceId: workspace.id
+    },
+    options
+  );
+  const liveUrl = matchingRecord?.liveUrl || buildLiveUrl(auth.baseUrl, initiative.id);
+  const decision = matchingRecord?.decisionId ? matchingRecord.decisionStatus === "approved" && matchingRecord.decisionTitle ? {
+    id: matchingRecord.decisionId,
+    status: matchingRecord.decisionStatus,
+    title: matchingRecord.decisionTitle
+  } : await approveFounderDemoDecision(matchingRecord.decisionId, options) : await approveFounderDemoDecision(
+    (await createFounderDemoDecision(initiative, workspace.id, options)).id,
+    options
+  );
+  const artifact = matchingRecord?.artifactId && matchingRecord.artifactName ? {
+    id: matchingRecord.artifactId,
+    name: matchingRecord.artifactName,
+    ...matchingRecord.artifactType ? { type: matchingRecord.artifactType } : {},
+    ...matchingRecord.artifactUrl ? { url: matchingRecord.artifactUrl } : {}
+  } : await createFounderDemoArtifact(initiative, liveUrl, workspace.id, options);
+  const record = toDemoInitiativeRecord(artifact, decision, initiative, liveUrl, workspace);
+  updateWizardState(
+    (current) => ({
+      ...current,
+      demoInitiative: record
+    }),
+    options.statePath
   );
   return {
-    created: true,
+    artifact,
+    created: !matchingRecord,
+    decision,
     initiative,
     liveUrl
   };
 }
+async function ensureOnboardingTask(workspace, options = {}) {
+  const existingRecord = readWizardState(options.statePath)?.onboardingTask;
+  if (existingRecord?.workspaceId === workspace.id) {
+    return {
+      id: existingRecord.id,
+      title: existingRecord.title,
+      ...existingRecord.status ? { status: existingRecord.status } : {}
+    };
+  }
+  const task = await createEntity(
+    "task",
+    {
+      status: "todo",
+      summary: ONBOARDING_TASK_SUMMARY,
+      title: ONBOARDING_TASK_TITLE,
+      workspace_id: workspace.id,
+      ...options.initiativeId ? { initiative_id: options.initiativeId } : {}
+    },
+    parseTask,
+    options
+  );
+  updateWizardState(
+    (current) => ({
+      ...current,
+      onboardingTask: toOnboardingTaskRecord(task, workspace, options.initiativeId)
+    }),
+    options.statePath
+  );
+  return task;
+}
 
 // src/lib/skills.ts
 import { join as join2 } from "path";
@@ -2615,6 +3142,7 @@ var DEFAULT_ORGX_SKILL_PACKS = [
   "bulk-create",
   "nightly-recap"
 ];
+var PLUGIN_MANAGED_SKILL_TARGETS = ["claude", "codex"];
 var EXCLUDED_PACK_DIRS = /* @__PURE__ */ new Set([".github", "scripts"]);
 var ORGX_SKILLS_OWNER = "useorgx";
 var ORGX_SKILLS_REPO = "skills";
@@ -2627,6 +3155,8 @@ var CURSOR_RULES_CONTENT = `# OrgX Rules
 - Preserve \`_context\` when widget or app-rendering flows depend on client, conversation, session, or user metadata. Do not strip or rename it.
 - Prefer \`list_entities\` for pending approvals and state inspection before reaching for legacy aliases.
 - Keep hosted OrgX MCP calls distinct from local OpenClaw/plugin surfaces before mutating config or entity state.
+- Artifact proof must use durable sources: GitHub PR/commit/blob permalinks, published/public URLs, or absolute file paths / \`file://...\`.
+- Never use OrgX wrapper pages like \`/live/...\`, \`/artifacts/...\`, or \`/console/...\` as proof links. \`preview_markdown\` is supplemental, not proof.
 `;
 var CLAUDE_ORGX_SKILL_CONTENT = `---
 name: orgx
@@ -2652,6 +3182,8 @@ This skill is for the hosted OrgX tool surface, not the local OpenClaw plugin. K
 - Treat \`scaffold_initiative continue_on_error\` as best-effort scaffolding. Use it only when partial creation is acceptable and inspect failures afterward.
 - Preserve \`_context\` when widget or app rendering depends on client, conversation, session, or user metadata.
 - Prefer \`list_entities\` over older aliases when you need pending decisions, blockers, or entity state.
+- Artifact proof must use durable sources: GitHub PR/commit/blob permalinks, published/public URLs, or absolute file paths / \`file://...\`.
+- Never use OrgX wrapper pages like \`/live/...\`, \`/artifacts/...\`, or \`/console/...\` as proof links. \`preview_markdown\` is supporting context only.
 
 ## Suggested Skill Packs
 
@@ -2742,85 +3274,972 @@ function writeManagedFile(path, content, label, sourceUrl) {
     writeTextFile(path, content);
   }
   return {
-    label,
-    path,
-    changed,
-    ...sourceUrl ? { sourceUrl } : {}
+    label,
+    path,
+    changed,
+    ...sourceUrl ? { sourceUrl } : {}
+  };
+}
+function resolveSkillPackNames(requested = []) {
+  if (requested.length === 0 || requested.includes("all")) {
+    return [...DEFAULT_ORGX_SKILL_PACKS];
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const normalized = [];
+  for (const name of requested) {
+    const next = name.trim();
+    if (!next || seen.has(next)) {
+      continue;
+    }
+    seen.add(next);
+    normalized.push(next);
+  }
+  return normalized;
+}
+function resolvePluginManagedSkillTargets(requested = []) {
+  const seen = /* @__PURE__ */ new Set();
+  const targets = [];
+  for (const rawTarget of requested) {
+    const target = rawTarget.trim().toLowerCase();
+    if (!PLUGIN_MANAGED_SKILL_TARGETS.includes(target)) {
+      continue;
+    }
+    if (seen.has(target)) {
+      continue;
+    }
+    seen.add(target);
+    targets.push(target);
+  }
+  return targets;
+}
+function planOrgxSkillsInstall(pluginTargets = []) {
+  const pluginManagedTargets = resolvePluginManagedSkillTargets(pluginTargets);
+  const managesClaudeSkills = pluginManagedTargets.includes("claude");
+  const notes = [];
+  if (managesClaudeSkills) {
+    notes.push(
+      "Claude Code plugin is installed, so the wizard skipped overlapping standalone Claude OrgX skill files and Claude skill-pack sync."
+    );
+  }
+  if (pluginManagedTargets.includes("codex")) {
+    notes.push(
+      "Codex companion plugin bundles its own OrgX skills, so `wizard skills add` only manages standalone editor assets outside Codex."
+    );
+  }
+  return {
+    installClaudeSkillBootstrap: !managesClaudeSkills,
+    installClaudeSkillPacks: !managesClaudeSkills,
+    notes,
+    pluginManagedTargets
+  };
+}
+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) {
+  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 relativePath = file.path.slice(`${rootPath}/`.length);
+    writes.push(
+      writeManagedFile(
+        join2(claudeSkillsDir, skillName, relativePath),
+        content,
+        `${skillName}/${relativePath}`,
+        file.sourceUrl
+      )
+    );
+  }
+  return {
+    name: skillName,
+    files: writes
+  };
+}
+async function installOrgxSkills(options = {}) {
+  const fetchImpl = options.fetchImpl ?? globalThis.fetch;
+  if (!fetchImpl) {
+    throw new Error("Global fetch is unavailable in this runtime.");
+  }
+  const ref = options.ref ?? ORGX_SKILLS_REF;
+  const claudeSkillsDir = options.claudeSkillsDir ?? CLAUDE_SKILLS_DIR;
+  const claudeOrgxSkillPath = options.claudeOrgxSkillPath ?? CLAUDE_ORGX_SKILL_PATH;
+  const cursorRulePath = options.cursorRulePath ?? CURSOR_ORGX_RULE_PATH;
+  const plan = planOrgxSkillsInstall(options.pluginTargets ?? []);
+  const requestedNames = options.skillNames ?? [];
+  let skillNames;
+  if (requestedNames.length === 0 || requestedNames.includes("all")) {
+    try {
+      skillNames = await fetchAvailablePackNames(fetchImpl, ref);
+    } catch {
+      skillNames = [...DEFAULT_ORGX_SKILL_PACKS];
+    }
+  } else {
+    skillNames = resolveSkillPackNames(requestedNames);
+  }
+  const writes = [
+    writeManagedFile(cursorRulePath, CURSOR_RULES_CONTENT, "cursor-rules")
+  ];
+  if (plan.installClaudeSkillBootstrap) {
+    writes.push(
+      writeManagedFile(claudeOrgxSkillPath, CLAUDE_ORGX_SKILL_CONTENT, "claude-orgx-skill")
+    );
+  }
+  const packs = [];
+  if (plan.installClaudeSkillPacks) {
+    for (const skillName of skillNames) {
+      packs.push(await installSkillPack(skillName, claudeSkillsDir, fetchImpl, ref));
+    }
+  }
+  return {
+    notes: plan.notes,
+    writes,
+    packs
+  };
+}
+
+// src/lib/plugins.ts
+import { spawn } from "child_process";
+import {
+  existsSync as existsSync3,
+  mkdirSync as mkdirSync2,
+  mkdtempSync,
+  readFileSync as readFileSync2,
+  readdirSync,
+  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 ORGX_PLUGIN_GITHUB_OWNER = "useorgx";
+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_OPENCLAW_PLUGIN_ID = "orgx";
+var ORGX_OPENCLAW_PLUGIN_PACKAGE_NAME = "@useorgx/openclaw-plugin";
+var CLAUDE_PLUGIN_SYNC_SPEC = {
+  owner: ORGX_PLUGIN_GITHUB_OWNER,
+  repo: ORGX_CLAUDE_PLUGIN_NAME,
+  ref: ORGX_PLUGIN_GITHUB_REF,
+  include: [
+    { localPath: ".claude-plugin", remotePath: ".claude-plugin" },
+    { localPath: "agents", remotePath: "agents" },
+    { localPath: "commands", remotePath: "commands" },
+    { localPath: "hooks", remotePath: "hooks" },
+    { localPath: "lib", remotePath: "lib" },
+    { localPath: "scripts", remotePath: "scripts" },
+    { localPath: "skills", remotePath: "skills" }
+  ]
+};
+var CODEX_PLUGIN_SYNC_SPEC = {
+  owner: ORGX_PLUGIN_GITHUB_OWNER,
+  repo: ORGX_CODEX_PLUGIN_NAME,
+  ref: ORGX_PLUGIN_GITHUB_REF,
+  include: [
+    { localPath: ".codex-plugin", remotePath: ".codex-plugin" },
+    { localPath: ".mcp.json", remotePath: ".mcp.json" },
+    { localPath: "assets", remotePath: "assets" },
+    { localPath: "skills", remotePath: "skills" }
+  ]
+};
+function defaultPluginPaths() {
+  return {
+    claudeMarketplaceDir: CLAUDE_MANAGED_MARKETPLACE_DIR,
+    claudeMarketplaceManifestPath: CLAUDE_MANAGED_MARKETPLACE_MANIFEST_PATH,
+    claudePluginDir: CLAUDE_MANAGED_PLUGIN_DIR,
+    codexMarketplacePath: CODEX_MARKETPLACE_PATH,
+    codexPluginDir: CODEX_ORGX_PLUGIN_DIR
+  };
+}
+function resolvePluginPaths(paths = {}) {
+  return {
+    ...defaultPluginPaths(),
+    ...paths
+  };
+}
+function isRepoDirectoryEntry(value) {
+  if (!value || typeof value !== "object") return false;
+  const entry = value;
+  const hasType = entry.type === "file" || entry.type === "dir";
+  return typeof entry.name === "string" && typeof entry.path === "string" && hasType;
+}
+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);
+}
+function buildContentsUrl2(spec, path) {
+  const encodedPath = encodeRepoPath2(path);
+  return `https://api.github.com/repos/${spec.owner}/${spec.repo}/contents/${encodedPath}?ref=${encodeURIComponent(spec.ref)}`;
+}
+function resolveGitHubError2(spec, status, path) {
+  const repoName = `${spec.owner}/${spec.repo}`;
+  if (status === 404) {
+    return `Could not find '${path}' in ${repoName}.`;
+  }
+  return `GitHub returned HTTP ${status} while loading '${path}' from ${repoName}.`;
+}
+async function fetchDirectoryEntries2(spec, path, fetchImpl) {
+  const response = await fetchImpl(buildContentsUrl2(spec, path), {
+    headers: {
+      Accept: "application/vnd.github+json"
+    },
+    signal: AbortSignal.timeout(1e4)
+  });
+  if (!response.ok) {
+    throw new Error(resolveGitHubError2(spec, response.status, path));
+  }
+  const data = await response.json();
+  if (!Array.isArray(data)) {
+    throw new Error(`Expected '${path}' to be a directory in ${spec.owner}/${spec.repo}.`);
+  }
+  return data.filter(isRepoDirectoryEntry).sort((left, right) => left.path.localeCompare(right.path));
+}
+async function fetchRepoFile(spec, path, fetchImpl) {
+  const response = await fetchImpl(buildContentsUrl2(spec, path), {
+    headers: {
+      Accept: "application/vnd.github+json"
+    },
+    signal: AbortSignal.timeout(1e4)
+  });
+  if (!response.ok) {
+    throw new Error(resolveGitHubError2(spec, response.status, path));
+  }
+  const data = await response.json();
+  if (!isRepoDirectoryEntry(data) || data.type !== "file" || typeof data.download_url !== "string") {
+    throw new Error(`Expected '${path}' to be a file in ${spec.owner}/${spec.repo}.`);
+  }
+  return data;
+}
+async function listRemoteRepoFiles(spec, path, localPath, fetchImpl) {
+  const files = [];
+  if (isLikelyRepoFilePath(path) && !path.endsWith("/")) {
+    const file = await fetchRepoFile(spec, path, fetchImpl);
+    files.push({
+      localPath,
+      path: file.path,
+      sourceUrl: file.download_url ?? ""
+    });
+    return files;
+  }
+  const entries = await fetchDirectoryEntries2(spec, path, fetchImpl);
+  for (const entry of entries) {
+    if (entry.type === "dir") {
+      files.push(
+        ...await listRemoteRepoFiles(
+          spec,
+          entry.path,
+          join3(localPath, entry.name),
+          fetchImpl
+        )
+      );
+      continue;
+    }
+    if (!entry.download_url) {
+      throw new Error(`GitHub did not provide a download URL for '${entry.path}'.`);
+    }
+    files.push({
+      localPath: join3(localPath, entry.name),
+      path: entry.path,
+      sourceUrl: entry.download_url
+    });
+  }
+  return files;
+}
+async function collectRemoteRepoFiles(spec, fetchImpl) {
+  const files = [];
+  for (const entry of spec.include) {
+    const isFile = isLikelyRepoFilePath(entry.remotePath) && !entry.remotePath.endsWith("/");
+    if (isFile) {
+      const file = await fetchRepoFile(spec, entry.remotePath, fetchImpl);
+      files.push({
+        localPath: entry.localPath,
+        path: file.path,
+        sourceUrl: file.download_url ?? ""
+      });
+      continue;
+    }
+    files.push(...await listRemoteRepoFiles(spec, entry.remotePath, entry.localPath, fetchImpl));
+  }
+  return files.sort((left, right) => left.localPath.localeCompare(right.localPath));
+}
+async function fetchRemoteBytes(sourceUrl, fetchImpl) {
+  const response = await fetchImpl(sourceUrl, {
+    headers: {
+      Accept: "application/octet-stream"
+    },
+    signal: AbortSignal.timeout(1e4)
+  });
+  if (!response.ok) {
+    throw new Error(`GitHub returned HTTP ${response.status} while downloading ${sourceUrl}.`);
+  }
+  return Buffer.from(await response.arrayBuffer());
+}
+function readBytesIfExists(path) {
+  if (!existsSync3(path)) return null;
+  try {
+    if (!statSync2(path).isFile()) {
+      return null;
+    }
+    return readFileSync2(path);
+  } catch (error) {
+    const code = typeof error === "object" && error && "code" in error ? String(error.code) : void 0;
+    if (code === "ENOENT" || code === "ENOTDIR" || code === "EISDIR") {
+      return null;
+    }
+    throw error;
+  }
+}
+function writeBytesIfChanged(path, bytes) {
+  const existing = readBytesIfExists(path);
+  if (existing && Buffer.compare(existing, bytes) === 0) {
+    return false;
+  }
+  mkdirSync2(dirname3(path), { recursive: true });
+  writeFileSync2(path, bytes);
+  return true;
+}
+function removePathIfExists(path) {
+  if (!existsSync3(path)) return false;
+  rmSync(path, { force: true, recursive: true });
+  return true;
+}
+function listRelativeFiles(root, base = root) {
+  if (!existsSync3(root)) return [];
+  if (!statSync2(root).isDirectory()) {
+    return [];
+  }
+  const files = [];
+  for (const entry of readdirSync(root, { withFileTypes: true })) {
+    const nextPath = join3(root, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...listRelativeFiles(nextPath, base));
+      continue;
+    }
+    if (entry.isFile()) {
+      files.push(relative(base, nextPath));
+    }
+  }
+  return files.sort();
+}
+function pruneEmptyDirectories(root, current = root) {
+  if (!existsSync3(current) || !statSync2(current).isDirectory()) {
+    return false;
+  }
+  let changed = false;
+  for (const entry of readdirSync(current, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    changed = pruneEmptyDirectories(root, join3(current, entry.name)) || changed;
+  }
+  if (current !== root && readdirSync(current).length === 0) {
+    rmSync(current, { force: true, recursive: true });
+    return true;
+  }
+  return changed;
+}
+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()) {
+    rmSync(destinationRoot, { force: true, recursive: true });
+    changed = true;
+  }
+  for (const file of listRelativeFiles(destinationRoot)) {
+    if (expected.has(file)) continue;
+    rmSync(join3(destinationRoot, file), { force: true });
+    changed = true;
+  }
+  changed = pruneEmptyDirectories(destinationRoot) || changed;
+  for (const file of remoteFiles) {
+    const bytes = await fetchRemoteBytes(file.sourceUrl, fetchImpl);
+    if (writeBytesIfChanged(join3(destinationRoot, file.localPath), bytes)) {
+      changed = true;
+    }
+  }
+  return { changed, fileCount: remoteFiles.length };
+}
+function serializeJson(value) {
+  return `${JSON.stringify(value, null, 2)}
+`;
+}
+function writeJsonIfChanged(path, value) {
+  const next = serializeJson(value);
+  const existing = readTextIfExists(path);
+  if (existing === next) {
+    return false;
+  }
+  mkdirSync2(dirname3(path), { recursive: true });
+  writeFileSync2(path, next, "utf8");
+  return true;
+}
+function buildClaudeMarketplaceManifest() {
+  return {
+    $schema: "https://anthropic.com/claude-code/marketplace.schema.json",
+    name: ORGX_CLAUDE_MARKETPLACE_NAME,
+    description: "Local OrgX plugins",
+    owner: {
+      name: "OrgX Team"
+    },
+    plugins: [
+      {
+        name: ORGX_CLAUDE_PLUGIN_NAME,
+        description: "OrgX MCP tools and runtime telemetry hooks for Claude Code.",
+        source: `./plugins/${ORGX_CLAUDE_PLUGIN_NAME}`
+      }
+    ]
+  };
+}
+function buildCodexMarketplaceEntry() {
+  return {
+    name: ORGX_CODEX_PLUGIN_NAME,
+    source: {
+      source: "local",
+      path: `./.codex/plugins/${ORGX_CODEX_PLUGIN_NAME}`
+    },
+    policy: {
+      installation: "AVAILABLE",
+      authentication: "ON_INSTALL"
+    },
+    category: "Productivity"
+  };
+}
+function readMarketplacePlugins(path) {
+  const document = parseJsonObject(readTextIfExists(path));
+  const plugins = Array.isArray(document.plugins) ? document.plugins.filter((value) => Boolean(value) && typeof value === "object" && !Array.isArray(value)) : [];
+  return { document, plugins };
+}
+function upsertCodexMarketplaceEntry(path) {
+  const { document, plugins } = readMarketplacePlugins(path);
+  const nextEntry = buildCodexMarketplaceEntry();
+  let replaced = false;
+  const nextPlugins = plugins.map((plugin) => {
+    if (plugin.name !== ORGX_CODEX_PLUGIN_NAME) {
+      return plugin;
+    }
+    replaced = true;
+    return nextEntry;
+  });
+  if (!replaced) {
+    nextPlugins.push(nextEntry);
+  }
+  const nextDocument = {
+    ...document,
+    ...document.name ? {} : { name: ORGX_CLAUDE_MARKETPLACE_NAME },
+    ...readObject(document.interface).displayName ? {} : { interface: { displayName: "OrgX Local" } },
+    plugins: nextPlugins
+  };
+  return writeJsonIfChanged(path, nextDocument);
+}
+function removeCodexMarketplaceEntry(path) {
+  if (!existsSync3(path)) {
+    return false;
+  }
+  const { document, plugins } = readMarketplacePlugins(path);
+  const nextPlugins = plugins.filter((plugin) => plugin.name !== ORGX_CODEX_PLUGIN_NAME);
+  if (nextPlugins.length === plugins.length) {
+    return false;
+  }
+  if (nextPlugins.length === 0) {
+    rmSync(path, { force: true });
+    return true;
+  }
+  return writeJsonIfChanged(path, {
+    ...document,
+    plugins: nextPlugins
+  });
+}
+function codexMarketplaceHasOrgxEntry(path) {
+  const { plugins } = readMarketplacePlugins(path);
+  return plugins.some((plugin) => plugin.name === ORGX_CODEX_PLUGIN_NAME);
+}
+function extractClaudePluginNames(payload) {
+  try {
+    const parsed = JSON.parse(payload);
+    if (!Array.isArray(parsed)) return [];
+    return parsed.flatMap((entry) => {
+      if (typeof entry === "string") return [entry];
+      if (!entry || typeof entry !== "object") return [];
+      if (typeof entry.name === "string") return [entry.name];
+      if (typeof entry.id === "string") return [entry.id];
+      return [];
+    });
+  } catch {
+    return [];
+  }
+}
+function extractOpenclawPluginIds(payload) {
+  try {
+    const parsed = JSON.parse(payload);
+    if (Array.isArray(parsed)) {
+      return parsed.flatMap((entry) => {
+        if (!entry || typeof entry !== "object") return [];
+        if (typeof entry.id === "string") return [entry.id];
+        if (typeof entry.name === "string") return [entry.name];
+        return [];
+      });
+    }
+    const root = readObject(parsed);
+    const plugins = Array.isArray(root.plugins) ? root.plugins : [];
+    return plugins.flatMap((entry) => {
+      if (!entry || typeof entry !== "object") return [];
+      const item = entry;
+      if (typeof item.id === "string") return [item.id];
+      if (typeof item.name === "string") return [item.name];
+      return [];
+    });
+  } catch {
+    return [];
+  }
+}
+function formatCommandFailure(command, args, result) {
+  const detail = [result.stderr.trim(), result.stdout.trim()].find((value) => value.length > 0);
+  if (result.errorCode === "ENOENT") {
+    return `Command '${command}' is not available on PATH.`;
+  }
+  return `${command} ${args.join(" ")} failed${result.exitCode >= 0 ? ` with exit code ${result.exitCode}` : ""}${detail ? `: ${detail}` : "."}`;
+}
+async function defaultCommandRunner(command, args) {
+  return await new Promise((resolve) => {
+    const child = spawn(command, [...args], {
+      env: process.env,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.on("error", (error) => {
+      const errorCode = typeof error === "object" && error && "code" in error ? String(error.code) : void 0;
+      resolve({
+        exitCode: -1,
+        stdout,
+        stderr,
+        ...errorCode ? { errorCode } : {}
+      });
+    });
+    child.on("close", (code) => {
+      resolve({
+        exitCode: code ?? -1,
+        stdout,
+        stderr
+      });
+    });
+  });
+}
+function resolveCommandRunner(runner) {
+  return runner ?? defaultCommandRunner;
+}
+async function commandExists(command, runner) {
+  const result = await runner(command, ["--help"]);
+  return result.errorCode !== "ENOENT" && result.exitCode !== 127;
+}
+async function getClaudeInstallState(runner) {
+  const available = detectSurface("claude").detected || await commandExists("claude", runner);
+  if (!available) {
+    return { available: false, installed: false };
+  }
+  const result = await runner("claude", ["plugin", "list", "--json"]);
+  if (result.exitCode !== 0) {
+    return { available: true, installed: false };
+  }
+  return {
+    available: true,
+    installed: extractClaudePluginNames(result.stdout).includes(ORGX_CLAUDE_PLUGIN_NAME)
+  };
+}
+async function getOpenclawInstallState(runner) {
+  const available = detectSurface("openclaw").detected || await commandExists("openclaw", runner);
+  if (!available) {
+    return { available: false, installed: false };
+  }
+  const result = await runner("openclaw", ["plugins", "list", "--json"]);
+  if (result.exitCode !== 0) {
+    return { available: true, installed: false };
+  }
+  return {
+    available: true,
+    installed: extractOpenclawPluginIds(result.stdout).includes(ORGX_OPENCLAW_PLUGIN_ID)
+  };
+}
+async function buildClaudeStatus(paths, runner) {
+  const state = await getClaudeInstallState(runner);
+  if (state.installed) {
+    return {
+      target: "claude",
+      available: true,
+      installed: true,
+      message: "Claude Code plugin is installed."
+    };
+  }
+  if (!state.available) {
+    return {
+      target: "claude",
+      available: false,
+      installed: false,
+      message: "Claude Code was not detected."
+    };
+  }
+  const marketplaceExists = existsSync3(paths.claudeMarketplaceManifestPath);
+  return {
+    target: "claude",
+    available: true,
+    installed: false,
+    message: marketplaceExists ? "Claude marketplace wrapper exists, but the plugin is not installed." : "Claude Code is available and ready for plugin install."
+  };
+}
+function buildCodexStatus(paths, runner) {
+  return (async () => {
+    const available = detectSurface("codex").detected || await commandExists("codex", runner);
+    const pluginExists = existsSync3(paths.codexPluginDir);
+    const marketplaceExists = codexMarketplaceHasOrgxEntry(paths.codexMarketplacePath);
+    const installed = pluginExists && marketplaceExists;
+    if (installed) {
+      return {
+        target: "codex",
+        available: true,
+        installed: true,
+        message: "Codex plugin files and marketplace entry are present."
+      };
+    }
+    if (!available) {
+      return {
+        target: "codex",
+        available: false,
+        installed: false,
+        message: "Codex was not detected."
+      };
+    }
+    if (pluginExists && !marketplaceExists) {
+      return {
+        target: "codex",
+        available: true,
+        installed: false,
+        message: "Codex plugin files exist, but the marketplace entry is missing."
+      };
+    }
+    if (!pluginExists && marketplaceExists) {
+      return {
+        target: "codex",
+        available: true,
+        installed: false,
+        message: "Codex marketplace entry exists, but plugin files are missing."
+      };
+    }
+    return {
+      target: "codex",
+      available: true,
+      installed: false,
+      message: "Codex is available and ready for plugin install."
+    };
+  })();
+}
+async function buildOpenclawStatus(runner) {
+  const state = await getOpenclawInstallState(runner);
+  if (state.installed) {
+    return {
+      target: "openclaw",
+      available: true,
+      installed: true,
+      message: "OpenClaw plugin is installed."
+    };
+  }
+  return {
+    target: "openclaw",
+    available: state.available,
+    installed: false,
+    message: state.available ? "OpenClaw is available and ready for plugin install." : "OpenClaw was not detected."
+  };
+}
+async function resolveOpenclawTarball(fetchImpl) {
+  const response = await fetchImpl(
+    `${NPM_REGISTRY_BASE_URL}/${encodeURIComponent(ORGX_OPENCLAW_PLUGIN_PACKAGE_NAME)}`,
+    {
+      headers: {
+        Accept: "application/json"
+      },
+      signal: AbortSignal.timeout(1e4)
+    }
+  );
+  if (!response.ok) {
+    throw new Error(
+      `npm registry returned HTTP ${response.status} while resolving ${ORGX_OPENCLAW_PLUGIN_PACKAGE_NAME}.`
+    );
+  }
+  const data = await response.json();
+  const latestVersion = data["dist-tags"]?.latest;
+  const tarballUrl = latestVersion ? data.versions?.[latestVersion]?.dist?.tarball : void 0;
+  if (!latestVersion || !tarballUrl) {
+    throw new Error(`Could not resolve a tarball URL for ${ORGX_OPENCLAW_PLUGIN_PACKAGE_NAME}.`);
+  }
+  return {
+    tarballUrl,
+    version: latestVersion
+  };
+}
+async function installClaudePlugin(paths, fetchImpl, runner) {
+  const state = await getClaudeInstallState(runner);
+  if (!state.available) {
+    return {
+      target: "claude",
+      changed: false,
+      message: "Claude Code is not available on this machine."
+    };
+  }
+  const syncResult = await syncManagedRepoTree(CLAUDE_PLUGIN_SYNC_SPEC, paths.claudePluginDir, fetchImpl);
+  const manifestChanged = writeJsonIfChanged(
+    paths.claudeMarketplaceManifestPath,
+    buildClaudeMarketplaceManifest()
+  );
+  const marketplaceAdd = await runner("claude", ["plugin", "marketplace", "add", paths.claudeMarketplaceDir]);
+  if (marketplaceAdd.exitCode !== 0) {
+    throw new Error(formatCommandFailure("claude", ["plugin", "marketplace", "add", paths.claudeMarketplaceDir], marketplaceAdd));
+  }
+  let installedChanged = false;
+  if (!state.installed) {
+    const install = await runner("claude", [
+      "plugin",
+      "install",
+      `${ORGX_CLAUDE_PLUGIN_NAME}@${ORGX_CLAUDE_MARKETPLACE_NAME}`,
+      "--scope",
+      "user"
+    ]);
+    if (install.exitCode !== 0) {
+      throw new Error(
+        formatCommandFailure(
+          "claude",
+          [
+            "plugin",
+            "install",
+            `${ORGX_CLAUDE_PLUGIN_NAME}@${ORGX_CLAUDE_MARKETPLACE_NAME}`,
+            "--scope",
+            "user"
+          ],
+          install
+        )
+      );
+    }
+    installedChanged = true;
+  }
+  const changed = syncResult.changed || manifestChanged || installedChanged;
+  return {
+    target: "claude",
+    changed,
+    message: changed ? `Synced ${syncResult.fileCount} Claude plugin files and ensured the plugin is installed.` : "Claude Code plugin is already installed and up to date."
+  };
+}
+async function installCodexPlugin(paths, fetchImpl, runner) {
+  const available = detectSurface("codex").detected || await commandExists("codex", runner);
+  if (!available) {
+    return {
+      target: "codex",
+      changed: false,
+      message: "Codex is not available on this machine."
+    };
+  }
+  const syncResult = await syncManagedRepoTree(CODEX_PLUGIN_SYNC_SPEC, paths.codexPluginDir, fetchImpl);
+  const marketplaceChanged = upsertCodexMarketplaceEntry(paths.codexMarketplacePath);
+  const changed = syncResult.changed || marketplaceChanged;
+  return {
+    target: "codex",
+    changed,
+    message: changed ? `Synced ${syncResult.fileCount} Codex plugin files and updated the marketplace entry.` : "Codex plugin files and marketplace entry already match the managed OrgX plugin."
+  };
+}
+async function installOpenclawPlugin(fetchImpl, runner) {
+  const state = await getOpenclawInstallState(runner);
+  if (!state.available) {
+    return {
+      target: "openclaw",
+      changed: false,
+      message: "OpenClaw is not available on this machine."
+    };
+  }
+  if (state.installed) {
+    return {
+      target: "openclaw",
+      changed: false,
+      message: "OpenClaw plugin is already installed."
+    };
+  }
+  const { tarballUrl, version } = await resolveOpenclawTarball(fetchImpl);
+  const tarballBytes = await fetchRemoteBytes(tarballUrl, fetchImpl);
+  const tempRoot = mkdtempSync(join3(tmpdir(), "orgx-wizard-openclaw-"));
+  const archivePath = join3(tempRoot, `orgx-openclaw-plugin-${version}.tgz`);
+  try {
+    writeFileSync2(archivePath, tarballBytes);
+    const install = await runner("openclaw", ["plugins", "install", archivePath]);
+    if (install.exitCode !== 0) {
+      throw new Error(
+        formatCommandFailure("openclaw", ["plugins", "install", archivePath], install)
+      );
+    }
+  } finally {
+    rmSync(tempRoot, { force: true, recursive: true });
+  }
+  return {
+    target: "openclaw",
+    changed: true,
+    message: `Installed OpenClaw plugin ${ORGX_OPENCLAW_PLUGIN_ID} from ${ORGX_OPENCLAW_PLUGIN_PACKAGE_NAME}@${version}.`
+  };
+}
+async function uninstallClaudePlugin(paths, runner) {
+  const state = await getClaudeInstallState(runner);
+  let changed = false;
+  if (state.available && state.installed) {
+    const uninstall = await runner("claude", [
+      "plugin",
+      "uninstall",
+      ORGX_CLAUDE_PLUGIN_NAME,
+      "--scope",
+      "user"
+    ]);
+    if (uninstall.exitCode !== 0) {
+      throw new Error(
+        formatCommandFailure(
+          "claude",
+          ["plugin", "uninstall", ORGX_CLAUDE_PLUGIN_NAME, "--scope", "user"],
+          uninstall
+        )
+      );
+    }
+    changed = true;
+  }
+  if (state.available) {
+    const removeMarketplace = await runner("claude", ["plugin", "marketplace", "remove", ORGX_CLAUDE_MARKETPLACE_NAME]);
+    if (removeMarketplace.exitCode === 0) {
+      changed = true;
+    }
+  }
+  changed = removePathIfExists(paths.claudeMarketplaceDir) || changed;
+  return {
+    target: "claude",
+    changed,
+    message: changed ? "Removed the managed Claude Code plugin and marketplace wrapper." : "Claude Code plugin was not installed."
+  };
+}
+async function uninstallCodexPlugin(paths) {
+  const removedPluginDir = removePathIfExists(paths.codexPluginDir);
+  const removedMarketplaceEntry = removeCodexMarketplaceEntry(paths.codexMarketplacePath);
+  const changed = removedPluginDir || removedMarketplaceEntry;
+  return {
+    target: "codex",
+    changed,
+    message: changed ? "Removed the managed Codex plugin files and marketplace entry." : "Codex plugin was not installed."
+  };
+}
+async function uninstallOpenclawPlugin(runner) {
+  const state = await getOpenclawInstallState(runner);
+  if (!state.available || !state.installed) {
+    return {
+      target: "openclaw",
+      changed: false,
+      message: "OpenClaw plugin was not installed."
+    };
+  }
+  const uninstall = await runner("openclaw", ["plugins", "uninstall", ORGX_OPENCLAW_PLUGIN_ID, "--force"]);
+  if (uninstall.exitCode !== 0) {
+    throw new Error(
+      formatCommandFailure(
+        "openclaw",
+        ["plugins", "uninstall", ORGX_OPENCLAW_PLUGIN_ID, "--force"],
+        uninstall
+      )
+    );
+  }
+  return {
+    target: "openclaw",
+    changed: true,
+    message: "Removed the managed OpenClaw plugin."
   };
 }
-function resolveSkillPackNames(requested = []) {
+function resolvePluginTargets(requested = []) {
   if (requested.length === 0 || requested.includes("all")) {
-    return [...DEFAULT_ORGX_SKILL_PACKS];
+    return [...DEFAULT_ORGX_PLUGIN_TARGETS];
   }
   const seen = /* @__PURE__ */ new Set();
   const normalized = [];
-  for (const name of requested) {
-    const next = name.trim();
-    if (!next || seen.has(next)) {
-      continue;
+  for (const rawTarget of requested) {
+    const target = rawTarget.trim().toLowerCase();
+    if (target === "" || target === "all") continue;
+    if (!DEFAULT_ORGX_PLUGIN_TARGETS.includes(target)) {
+      throw new Error(
+        `Unknown plugin target '${rawTarget}'. Supported targets: ${DEFAULT_ORGX_PLUGIN_TARGETS.join(", ")}.`
+      );
     }
-    seen.add(next);
-    normalized.push(next);
+    const nextTarget = target;
+    if (seen.has(nextTarget)) continue;
+    seen.add(nextTarget);
+    normalized.push(nextTarget);
   }
   return normalized;
 }
-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) {
-  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 relativePath = file.path.slice(`${rootPath}/`.length);
-    writes.push(
-      writeManagedFile(
-        join2(claudeSkillsDir, skillName, relativePath),
-        content,
-        `${skillName}/${relativePath}`,
-        file.sourceUrl
-      )
-    );
-  }
-  return {
-    name: skillName,
-    files: writes
-  };
-}
-async function installOrgxSkills(options = {}) {
+async function listOrgxPluginStatuses(options = {}) {
+  const paths = resolvePluginPaths(options.paths);
+  const runner = resolveCommandRunner(options.commandRunner);
+  return await Promise.all([
+    buildClaudeStatus(paths, runner),
+    buildCodexStatus(paths, runner),
+    buildOpenclawStatus(runner)
+  ]);
+}
+async function installOrgxPlugins(options = {}) {
+  const targets = resolvePluginTargets(options.targets ?? []);
   const fetchImpl = options.fetchImpl ?? globalThis.fetch;
   if (!fetchImpl) {
     throw new Error("Global fetch is unavailable in this runtime.");
   }
-  const ref = options.ref ?? ORGX_SKILLS_REF;
-  const claudeSkillsDir = options.claudeSkillsDir ?? CLAUDE_SKILLS_DIR;
-  const claudeOrgxSkillPath = options.claudeOrgxSkillPath ?? CLAUDE_ORGX_SKILL_PATH;
-  const cursorRulePath = options.cursorRulePath ?? CURSOR_ORGX_RULE_PATH;
-  const requestedNames = options.skillNames ?? [];
-  let skillNames;
-  if (requestedNames.length === 0 || requestedNames.includes("all")) {
-    try {
-      skillNames = await fetchAvailablePackNames(fetchImpl, ref);
-    } catch {
-      skillNames = [...DEFAULT_ORGX_SKILL_PACKS];
+  const paths = resolvePluginPaths(options.paths);
+  const runner = resolveCommandRunner(options.commandRunner);
+  const results = [];
+  for (const target of targets) {
+    switch (target) {
+      case "claude":
+        results.push(await installClaudePlugin(paths, fetchImpl, runner));
+        break;
+      case "codex":
+        results.push(await installCodexPlugin(paths, fetchImpl, runner));
+        break;
+      case "openclaw":
+        results.push(await installOpenclawPlugin(fetchImpl, runner));
+        break;
     }
-  } else {
-    skillNames = resolveSkillPackNames(requestedNames);
   }
-  const writes = [
-    writeManagedFile(cursorRulePath, CURSOR_RULES_CONTENT, "cursor-rules"),
-    writeManagedFile(claudeOrgxSkillPath, CLAUDE_ORGX_SKILL_CONTENT, "claude-orgx-skill")
-  ];
-  const packs = [];
-  for (const skillName of skillNames) {
-    packs.push(await installSkillPack(skillName, claudeSkillsDir, fetchImpl, ref));
+  return { results };
+}
+async function uninstallOrgxPlugins(options = {}) {
+  const targets = resolvePluginTargets(options.targets ?? []);
+  const paths = resolvePluginPaths(options.paths);
+  const runner = resolveCommandRunner(options.commandRunner);
+  const results = [];
+  for (const target of targets) {
+    switch (target) {
+      case "claude":
+        results.push(await uninstallClaudePlugin(paths, runner));
+        break;
+      case "codex":
+        results.push(await uninstallCodexPlugin(paths));
+        break;
+      case "openclaw":
+        results.push(await uninstallOpenclawPlugin(runner));
+        break;
+    }
   }
-  return {
-    writes,
-    packs
-  };
+  return { results };
+}
+function countPluginReportChanges(report) {
+  return report.results.filter((result) => result.changed).length;
 }
 
 // src/lib/setup-workspace.ts
@@ -3010,7 +4429,9 @@ async function runWorkspaceSetup(client, prompts, options) {
 // src/lib/founder-preset.ts
 async function runFounderPreset(prompts, options) {
   const surfaceResults = await setupDetectedSurfaces();
+  const pluginTargets = options.pluginTargets ?? (await listOrgxPluginStatuses()).filter((status) => status.installed).map((status) => status.target);
   const skillReport = await installOrgxSkills({
+    pluginTargets,
     skillNames: [...DEFAULT_ORGX_SKILL_PACKS]
   });
   let workspaceSetup;
@@ -3058,6 +4479,179 @@ function summarizeMutationResults(results) {
   }));
 }
 
+// src/lib/setup-verification.ts
+var HOSTED_MCP_OUTAGE_TITLE = "Hosted OrgX MCP is unreachable.";
+function getSetupVerificationHeadline(summary) {
+  switch (summary.status) {
+    case "degraded":
+      return "Hosted OrgX MCP is down; local setup can still continue.";
+    case "error":
+      return "Issues detected";
+    case "warning":
+      return "Warnings detected";
+    case "ok":
+      return "All systems ready.";
+  }
+}
+function summarizeSetupVerification(assessment) {
+  const errors = assessment.issues.filter((issue) => issue.level === "error");
+  if (errors.length === 0) {
+    return {
+      hostedMcpDegraded: false,
+      status: assessment.issues.length > 0 ? "warning" : "ok"
+    };
+  }
+  const hostedMcpDegraded = errors.every((issue) => issue.title === HOSTED_MCP_OUTAGE_TITLE);
+  return {
+    hostedMcpDegraded,
+    status: hostedMcpDegraded ? "degraded" : "error"
+  };
+}
+
+// src/lib/telemetry-events.ts
+function withBaseProperties(properties, base) {
+  return {
+    ...base,
+    ...properties
+  };
+}
+function buildWorkspaceSetupTelemetryProperties(result, base = {}) {
+  return withBaseProperties(
+    {
+      created: result.created === true,
+      default_changed: result.defaultChanged === true,
+      has_workspace: Boolean(result.workspace),
+      status: result.status
+    },
+    base
+  );
+}
+function buildOnboardingTaskTelemetryProperties(input, base = {}) {
+  return withBaseProperties(
+    {
+      created: input.created,
+      has_initiative: input.hasInitiative,
+      task_status: input.task.status ?? "unknown"
+    },
+    base
+  );
+}
+function buildAgentRosterTelemetryProperties(input, base = {}) {
+  return withBaseProperties(
+    {
+      agent_count: input.roster.agents.length,
+      domain_count: new Set(input.roster.agents.map((agent) => agent.domain)).size,
+      strategy: input.strategy
+    },
+    base
+  );
+}
+function buildFounderDemoTelemetryProperties(result, base = {}) {
+  return withBaseProperties(
+    {
+      created: result.created,
+      decision_status: result.decision.status ?? "unknown",
+      has_artifact_url: Boolean(result.artifact.url)
+    },
+    base
+  );
+}
+function buildDoctorTelemetryProperties(report, assessment, verification, base = {}) {
+  const errorCount = assessment.issues.filter((issue) => issue.level === "error").length;
+  const warningCount = assessment.issues.filter((issue) => issue.level === "warning").length;
+  return withBaseProperties(
+    {
+      auth_configured: report.auth.configured,
+      auth_ok: report.auth.ok,
+      configured_surface_count: report.surfaces.filter((surface) => surface.configured).length,
+      detected_surface_count: report.surfaces.filter((surface) => surface.detected).length,
+      error_count: errorCount,
+      hosted_mcp_degraded: verification.hostedMcpDegraded,
+      hosted_mcp_ok: report.hostedMcp.ok,
+      hosted_mcp_tool_ok: report.hostedMcpTool.ok,
+      issue_count: assessment.issues.length,
+      openclaw_available: !report.openclaw.skipped,
+      openclaw_ok: report.openclaw.ok,
+      status: verification.status,
+      warning_count: warningCount,
+      workspace_configured: report.workspace.configured,
+      workspace_ok: report.workspace.ok
+    },
+    base
+  );
+}
+
+// src/lib/telemetry.ts
+var POSTHOG_DEFAULT_HOST = "https://us.i.posthog.com";
+var WIZARD_LIB = "@useorgx/wizard";
+function isTruthyEnv(value) {
+  if (!value) return false;
+  switch (value.trim().toLowerCase()) {
+    case "1":
+    case "true":
+    case "yes":
+    case "y":
+    case "on":
+      return true;
+    default:
+      return false;
+  }
+}
+function isWizardTelemetryDisabled() {
+  const explicitEnable = isTruthyEnv(process.env.ORGX_TELEMETRY_ENABLED);
+  if (!explicitEnable) return true;
+  return isTruthyEnv(process.env.ORGX_TELEMETRY_DISABLED) || isTruthyEnv(process.env.OPENCLAW_TELEMETRY_DISABLED) || isTruthyEnv(process.env.POSTHOG_DISABLED);
+}
+function resolvePosthogApiKey() {
+  const value = process.env.ORGX_POSTHOG_API_KEY ?? process.env.POSTHOG_API_KEY ?? process.env.ORGX_POSTHOG_KEY ?? process.env.POSTHOG_KEY ?? "";
+  const trimmed = value.trim();
+  return trimmed || null;
+}
+function resolvePosthogHost() {
+  const value = process.env.ORGX_POSTHOG_HOST ?? process.env.POSTHOG_HOST ?? process.env.ORGX_POSTHOG_API_HOST ?? process.env.POSTHOG_API_HOST ?? "";
+  const trimmed = value.trim();
+  return trimmed || POSTHOG_DEFAULT_HOST;
+}
+function toPosthogBatchUrl(host) {
+  try {
+    return new URL("/batch/", host).toString();
+  } catch {
+    return `${POSTHOG_DEFAULT_HOST}/batch/`;
+  }
+}
+async function trackWizardTelemetry(event, properties = {}, options = {}) {
+  if (isWizardTelemetryDisabled()) return false;
+  const apiKey = resolvePosthogApiKey();
+  if (!apiKey) return false;
+  const installationId = getOrCreateWizardInstallationId(options.statePath);
+  const timestamp = options.timestamp ?? (/* @__PURE__ */ new Date()).toISOString();
+  const response = await fetch(toPosthogBatchUrl(resolvePosthogHost()), {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      api_key: apiKey,
+      batch: [
+        {
+          type: "capture",
+          event,
+          distinct_id: installationId,
+          properties: {
+            $lib: WIZARD_LIB,
+            source: WIZARD_LIB,
+            wizard_installation_id: installationId,
+            ...properties
+          },
+          timestamp
+        }
+      ],
+      sent_at: timestamp
+    })
+  }).catch(() => null);
+  return response?.ok === true;
+}
+
 // src/spinner.ts
 import ora from "ora";
 import pc2 from "picocolors";
@@ -3095,12 +4689,34 @@ function formatAuthSource(source) {
       return "not configured";
   }
 }
+function formatPluginTargetLabel(target) {
+  switch (target) {
+    case "claude":
+      return "Claude Code";
+    case "codex":
+      return "Codex";
+    case "openclaw":
+      return "OpenClaw";
+  }
+}
 function printSurfaceTable(statuses) {
   for (const status of statuses) {
     const icon = status.configured ? ICON.ok : status.detected ? ICON.warn : ICON.skip;
     const state = status.configured ? pc3.green("configured") : status.detected ? pc3.yellow("detected") : pc3.dim("not found");
     const mode = pc3.dim(status.mode === "automated" ? "auto  " : "manual");
     console.log(`  ${icon}  ${pc3.bold(status.name.padEnd(10))} ${mode}  ${state}`);
+    if (status.mode === "manual") {
+      console.log(`       ${pc3.dim(status.summary)}`);
+    }
+  }
+}
+function printPluginStatusReport(statuses) {
+  for (const status of statuses) {
+    const icon = status.installed ? ICON.ok : status.available ? ICON.warn : ICON.skip;
+    const state = status.installed ? pc3.green("installed") : status.available ? pc3.yellow("available") : pc3.dim("not found");
+    console.log(
+      `  ${icon}  ${pc3.bold(formatPluginTargetLabel(status.target).padEnd(12))} ${state}  ${pc3.dim(status.message)}`
+    );
   }
 }
 function printMutationResults(results) {
@@ -3110,6 +4726,15 @@ function printMutationResults(results) {
     console.log(`  ${icon}  ${pc3.bold(result.name.padEnd(10))} ${state}  ${pc3.dim(result.message)}`);
   }
 }
+function printPluginMutationReport(report) {
+  for (const result of report.results) {
+    const icon = result.changed ? ICON.ok : ICON.skip;
+    const state = result.changed ? pc3.green("updated  ") : pc3.dim("unchanged");
+    console.log(
+      `  ${icon}  ${pc3.bold(formatPluginTargetLabel(result.target).padEnd(12))} ${state}  ${pc3.dim(result.message)}`
+    );
+  }
+}
 function printSkillInstallReport(report) {
   for (const write of report.writes) {
     const icon = write.changed ? ICON.ok : ICON.skip;
@@ -3122,6 +4747,23 @@ function printSkillInstallReport(report) {
     const state = 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 note of report.notes) {
+    console.log(`  ${ICON.skip}  ${pc3.dim(note)}`);
+  }
+}
+function countSkillReportChanges(report) {
+  const writeChanges = report.writes.filter((write) => write.changed).length;
+  const packChanges = report.packs.reduce(
+    (count, pack) => count + pack.files.filter((file) => file.changed).length,
+    0
+  );
+  return writeChanges + packChanges;
+}
+async function safeTrackWizardTelemetry(event, properties = {}) {
+  try {
+    await trackWizardTelemetry(event, properties);
+  } catch {
+  }
 }
 function printWorkspace(workspace) {
   console.log(
@@ -3170,6 +4812,12 @@ function printFounderPresetResult(result) {
       `  ${result.demoInitiative.created ? pc3.green("created") : pc3.yellow("unchanged")} ${result.demoInitiative.initiative.title}`
     );
     console.log(`  live: ${result.demoInitiative.liveUrl}`);
+    console.log(
+      `  decision: ${result.demoInitiative.decision.title} ${pc3.dim(`(${result.demoInitiative.decision.status ?? "pending"})`)}`
+    );
+    console.log(
+      `  artifact: ${result.demoInitiative.artifact.name}${result.demoInitiative.artifact.url ? ` ${pc3.dim(result.demoInitiative.artifact.url)}` : ""}`
+    );
   }
 }
 function normalizePromptResult(value) {
@@ -3187,6 +4835,64 @@ async function textPrompt(input) {
   };
   return normalizePromptResult(await clack.text(promptInput));
 }
+async function multiselectPrompt(input) {
+  const promptInput = {
+    message: input.message,
+    options: input.options,
+    ...input.required !== void 0 ? { required: input.required } : {}
+  };
+  return normalizePromptResult(await clack.multiselect(promptInput));
+}
+function printAgentRoster(roster) {
+  console.log(`  ${ICON.ok}  ${pc3.green("agent roster")} ${pc3.bold(`${roster.agents.length} agents`)}`);
+  for (const agent of roster.agents) {
+    console.log(
+      `       ${pc3.dim(agent.domain.padEnd(12))} ${pc3.bold(agent.name)} ${pc3.dim(agent.agentType)}`
+    );
+  }
+}
+async function promptForGuidedAgentRoster(workspace) {
+  const remainingAgents = listAgentRosterProfiles();
+  const assignments = [];
+  for (const domain of AGENT_ROSTER_DOMAINS) {
+    if (remainingAgents.length === 0) {
+      break;
+    }
+    const defaultAgent = remainingAgents.find((agent) => agent.defaultDomain === domain);
+    const choice = await selectPrompt({
+      initialValue: defaultAgent?.name ?? "skip",
+      message: `Assign an OrgX agent to the ${domain} domain`,
+      options: [
+        ...remainingAgents.map((agent) => ({
+          value: agent.name,
+          label: agent.name,
+          hint: `${agent.agentType} \xB7 default ${agent.defaultDomain}`
+        })),
+        { value: "skip", label: `Leave ${domain} unassigned`, hint: "optional" }
+      ]
+    });
+    if (clack.isCancel(choice)) {
+      clack.cancel("Setup cancelled.");
+      return "cancelled";
+    }
+    if (choice === "skip") {
+      continue;
+    }
+    const index = remainingAgents.findIndex((agent) => agent.name === choice);
+    if (index === -1) {
+      continue;
+    }
+    const [selectedAgent] = remainingAgents.splice(index, 1);
+    if (!selectedAgent) {
+      continue;
+    }
+    assignments.push({ domain, name: selectedAgent.name });
+  }
+  if (assignments.length === 0) {
+    return null;
+  }
+  return configureAgentRoster(workspace, assignments);
+}
 async function verifyAndPersistAuth(apiKey, options) {
   const trimmedKey = apiKey.trim();
   if (!trimmedKey.toLowerCase().startsWith("oxk_")) {
@@ -3207,6 +4913,10 @@ async function verifyAndPersistAuth(apiKey, options) {
     baseUrl,
     verifiedAt: (/* @__PURE__ */ new Date()).toISOString()
   });
+  await safeTrackWizardTelemetry("auth_completed", {
+    auth_source: options.telemetrySource ?? "manual_api_key",
+    has_base_url: Boolean(baseUrl)
+  });
   const openclawResults = detectSurface("openclaw").detected ? await addSurface("openclaw") : [];
   return { openclawResults, stored, verification };
 }
@@ -3228,6 +4938,168 @@ function parseTimeoutSeconds(value) {
   }
   return parsed;
 }
+async function maybeConfigureOptionalWorkspaceAddOns(input) {
+  if (!input.interactive || !input.workspace) {
+    return "skipped";
+  }
+  const existingState = readWizardState();
+  const hasOnboardingTask = existingState?.onboardingTask?.workspaceId === input.workspace.id;
+  if (!hasOnboardingTask) {
+    const onboardingChoice = await selectPrompt({
+      message: `Create a starter onboarding task for ${input.workspace.name}?`,
+      options: [
+        { value: "yes", label: "Create onboarding task", hint: "recommended" },
+        { value: "no", label: "Skip task creation" }
+      ]
+    });
+    if (clack.isCancel(onboardingChoice)) {
+      clack.cancel("Setup cancelled.");
+      return "cancelled";
+    }
+    if (onboardingChoice === "yes") {
+      const task = await ensureOnboardingTask(input.workspace, {
+        ...input.initiativeId ? { initiativeId: input.initiativeId } : {}
+      });
+      console.log(`  ${ICON.ok}  ${pc3.green("onboarding")} ${pc3.bold(task.title)}`);
+      await safeTrackWizardTelemetry(
+        "onboarding_task_created",
+        buildOnboardingTaskTelemetryProperties(
+          {
+            created: true,
+            hasInitiative: Boolean(input.initiativeId),
+            task
+          },
+          {
+            command: input.telemetry?.command ?? "setup",
+            ...input.telemetry?.preset ? { preset: input.telemetry.preset } : {}
+          }
+        )
+      );
+    }
+  }
+  const refreshedState = readWizardState();
+  const hasAgentRoster = refreshedState?.agentRoster?.workspaceId === input.workspace.id;
+  if (!hasAgentRoster) {
+    const rosterChoice = await selectPrompt({
+      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: "no", label: "Skip roster setup" }
+      ]
+    });
+    if (clack.isCancel(rosterChoice)) {
+      clack.cancel("Setup cancelled.");
+      return "cancelled";
+    }
+    if (rosterChoice === "guided") {
+      const roster = await promptForGuidedAgentRoster(input.workspace);
+      if (roster === "cancelled") {
+        return "cancelled";
+      }
+      if (roster) {
+        printAgentRoster(roster);
+        await safeTrackWizardTelemetry(
+          "agent_roster_configured",
+          buildAgentRosterTelemetryProperties(
+            {
+              roster,
+              strategy: "guided"
+            },
+            {
+              command: input.telemetry?.command ?? "setup",
+              ...input.telemetry?.preset ? { preset: input.telemetry.preset } : {}
+            }
+          )
+        );
+      } else {
+        console.log(`  ${ICON.skip}  ${pc3.dim("agent roster skipped")} ${pc3.dim("(no agents selected)")}`);
+      }
+    } else if (rosterChoice === "default") {
+      const roster = ensureDefaultAgentRoster(input.workspace);
+      printAgentRoster(roster);
+      await safeTrackWizardTelemetry(
+        "agent_roster_configured",
+        buildAgentRosterTelemetryProperties(
+          {
+            roster,
+            strategy: "default"
+          },
+          {
+            command: input.telemetry?.command ?? "setup",
+            ...input.telemetry?.preset ? { preset: input.telemetry.preset } : {}
+          }
+        )
+      );
+    }
+  }
+  return "configured";
+}
+async function promptOptionalCompanionPluginTargets(input) {
+  if (!input.interactive) {
+    return [];
+  }
+  const statuses = await listOrgxPluginStatuses();
+  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?",
+    options: installable.map((status) => ({
+      value: status.target,
+      label: `Install ${formatPluginTargetLabel(status.target)}`,
+      hint: status.message
+    })),
+    required: false
+  });
+  if (clack.isCancel(selection)) {
+    clack.cancel("Setup cancelled.");
+    return "cancelled";
+  }
+  return selection;
+}
+function printPluginSkillOwnershipNote(targets) {
+  if (!targets.some((target) => 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."
+    )}`
+  );
+}
+async function installSelectedCompanionPlugins(input) {
+  if (input.targets.length === 0) {
+    return "skipped";
+  }
+  const spinner = createOrgxSpinner("Installing OrgX companion plugins");
+  spinner.start();
+  const report = await installOrgxPlugins({ targets: input.targets });
+  spinner.succeed("OrgX companion plugins processed");
+  printPluginMutationReport(report);
+  printPluginSkillOwnershipNote(input.targets);
+  await safeTrackWizardTelemetry("plugins_installed", {
+    changed_count: countPluginReportChanges(report),
+    command: input.telemetry?.command ?? "setup",
+    ...input.telemetry?.preset ? { preset: input.telemetry.preset } : {},
+    requested_target_count: input.targets.length,
+    target_count: report.results.length
+  });
+  return countPluginReportChanges(report) > 0 ? "configured" : "skipped";
+}
+async function maybeInstallOptionalCompanionPlugins(input) {
+  const selection = await promptOptionalCompanionPluginTargets({
+    interactive: input.interactive
+  });
+  if (selection === "cancelled") {
+    return "cancelled";
+  }
+  return await installSelectedCompanionPlugins({
+    targets: selection,
+    ...input.telemetry ? { telemetry: input.telemetry } : {}
+  });
+}
 function printAuthStatus(status) {
   if (!status.configured) {
     console.log(`  ${ICON.warn}  ${pc3.yellow("no account")}   run ${pc3.cyan(`${getCmd()} auth login`)} to connect`);
@@ -3242,6 +5114,7 @@ function printAuthStatus(status) {
   }
 }
 function printDoctorReport(report, assessment) {
+  const verification = summarizeSetupVerification(assessment);
   console.log(pc3.dim("  surfaces"));
   printSurfaceTable(report.surfaces);
   console.log("");
@@ -3290,11 +5163,12 @@ function printDoctorReport(report, assessment) {
       console.log(`  ${pc3.dim("\u2192")}  ${pc3.dim(`OrgX is active across ${configuredCount} editor${configuredCount !== 1 ? "s" : ""}`)}`);
     }
   } else {
-    const hasError = assessment.issues.some((i) => i.level === "error");
-    const headline = hasError ? `${ICON.err}  ${pc3.red("Issues detected")}` : `${ICON.warn}  ${pc3.yellow("Warnings detected")}`;
+    const headlineText = getSetupVerificationHeadline(verification);
+    const headline = verification.status === "error" ? `${ICON.err}  ${pc3.red(headlineText)}` : `${ICON.warn}  ${pc3.yellow(headlineText)}`;
     console.log(`  ${headline}`);
     for (const issue of assessment.issues) {
-      const label = issue.level === "error" ? pc3.red("error") : pc3.yellow("warn ");
+      const degradedHostedMcpIssue = verification.hostedMcpDegraded && issue.title === HOSTED_MCP_OUTAGE_TITLE;
+      const label = degradedHostedMcpIssue ? pc3.yellow("degr ") : issue.level === "error" ? pc3.red("error") : pc3.yellow("warn ");
       console.log(`
        ${label}  ${issue.title}`);
       console.log(`       ${pc3.dim("\u2192")}     ${issue.suggestion}`);
@@ -3304,16 +5178,28 @@ 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.7" : void 0;
+  const pkgVersion = true ? "0.1.8" : 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) => {
+    const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY);
+    await safeTrackWizardTelemetry("wizard_started", {
+      command: "setup",
+      interactive,
+      preset: options.preset ?? "standard"
+    });
     if (options.preset) {
       if (options.preset !== "founder") {
         throw new Error(`Unknown setup preset '${options.preset}'. Supported presets: founder.`);
       }
+      const founderPluginTargets = await promptOptionalCompanionPluginTargets({
+        interactive
+      });
+      if (founderPluginTargets === "cancelled") {
+        return;
+      }
       const spinner2 = createOrgxSpinner("Running founder setup preset");
       spinner2.start();
       const presetResult = await runFounderPreset(
@@ -3324,7 +5210,8 @@ async function main() {
           text: textPrompt
         },
         {
-          interactive: Boolean(process.stdin.isTTY && process.stdout.isTTY)
+          interactive,
+          pluginTargets: founderPluginTargets
         }
       );
       if ("status" in presetResult) {
@@ -3337,11 +5224,62 @@ async function main() {
       }
       spinner2.succeed("Founder setup preset complete");
       printFounderPresetResult(presetResult);
+      await safeTrackWizardTelemetry("mcp_injected", {
+        changed_count: presetResult.surfaceResults.filter((result) => result.changed).length,
+        preset: "founder",
+        surface_count: presetResult.surfaceResults.length
+      });
+      await safeTrackWizardTelemetry("skills_installed", {
+        changed_count: countSkillReportChanges(presetResult.skillReport),
+        pack_count: presetResult.skillReport.packs.length,
+        preset: "founder",
+        write_count: presetResult.skillReport.writes.length
+      });
+      if (presetResult.workspaceSetup) {
+        await safeTrackWizardTelemetry(
+          "workspace_bootstrapped",
+          buildWorkspaceSetupTelemetryProperties(presetResult.workspaceSetup, {
+            command: "setup",
+            interactive,
+            preset: "founder"
+          })
+        );
+      }
+      if (presetResult.demoInitiative) {
+        await safeTrackWizardTelemetry(
+          "founder_demo_ready",
+          buildFounderDemoTelemetryProperties(presetResult.demoInitiative, {
+            command: "setup",
+            preset: "founder"
+          })
+        );
+      }
+      const addOnResult = await maybeConfigureOptionalWorkspaceAddOns({
+        interactive,
+        telemetry: { command: "setup", preset: "founder" },
+        workspace: presetResult.workspace,
+        ...presetResult.demoInitiative ? { initiativeId: presetResult.demoInitiative.initiative.id } : {}
+      });
+      if (addOnResult === "cancelled") {
+        return;
+      }
+      await installSelectedCompanionPlugins({
+        telemetry: { command: "setup", preset: "founder" },
+        targets: founderPluginTargets
+      });
       console.log("");
       const doctor2 = await runDoctor();
       const assessment2 = assessDoctorReport(doctor2);
+      const verification2 = summarizeSetupVerification(assessment2);
+      await safeTrackWizardTelemetry(
+        "setup_verified",
+        buildDoctorTelemetryProperties(doctor2, assessment2, verification2, {
+          command: "setup",
+          preset: "founder"
+        })
+      );
       printDoctorReport(doctor2, assessment2);
-      if (!assessment2.ok) {
+      if (verification2.status === "error") {
         process.exitCode = 1;
       }
       return;
@@ -3351,10 +5289,14 @@ async function main() {
     const results = await setupDetectedSurfaces();
     spinner.succeed("Detected surfaces configured");
     printMutationResults(results);
+    await safeTrackWizardTelemetry("mcp_injected", {
+      changed_count: results.filter((result) => result.changed).length,
+      preset: "standard",
+      surface_count: results.length
+    });
     let resolvedAuth = await resolveOrgxAuth();
     if (!resolvedAuth) {
       console.log("");
-      const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY);
       if (interactive) {
         const choice = await selectPrompt({
           message: "Connect your OrgX account to enable workspace and AI tool access",
@@ -3368,7 +5310,7 @@ async function main() {
           return;
         }
         if (choice === "login") {
-          const loginOk = await runBrowserLogin();
+          const loginOk = await runBrowserLogin({ telemetrySource: "browser_pairing" });
           if (!loginOk) {
             console.log(`
   ${pc3.dim("\u2192")}  ${pc3.cyan(`${getCmd()} auth login`)}           ${pc3.dim("to try again")}`);
@@ -3404,25 +5346,60 @@ async function main() {
           text: textPrompt
         },
         {
-          interactive: Boolean(process.stdin.isTTY && process.stdout.isTTY)
+          interactive
         }
       );
       if (workspaceSetup.status === "cancelled") {
         return;
       }
+      await safeTrackWizardTelemetry(
+        "workspace_bootstrapped",
+        buildWorkspaceSetupTelemetryProperties(workspaceSetup, {
+          command: "setup",
+          interactive,
+          preset: "standard"
+        })
+      );
+      const resolvedWorkspace = workspaceSetup.workspace ?? await getCurrentWorkspace().catch(() => null);
+      if (resolvedWorkspace) {
+        persistContinuityDefaults({ workspace: resolvedWorkspace });
+      }
       if (workspaceSetup.workspace) {
         console.log(`  ${ICON.ok}  ${pc3.green("workspace ")} ${pc3.bold(workspaceSetup.workspace.name)}`);
       }
+      const addOnResult = await maybeConfigureOptionalWorkspaceAddOns({
+        interactive,
+        telemetry: { command: "setup", preset: "standard" },
+        workspace: resolvedWorkspace
+      });
+      if (addOnResult === "cancelled") {
+        return;
+      }
+      const pluginInstallResult = await maybeInstallOptionalCompanionPlugins({
+        interactive,
+        telemetry: { command: "setup", preset: "standard" }
+      });
+      if (pluginInstallResult === "cancelled") {
+        return;
+      }
     }
     const doctor = await runDoctor();
     const assessment = assessDoctorReport(doctor);
+    const verification = summarizeSetupVerification(assessment);
+    await safeTrackWizardTelemetry(
+      "setup_verified",
+      buildDoctorTelemetryProperties(doctor, assessment, verification, {
+        command: "setup",
+        preset: "standard"
+      })
+    );
     const configuredCount = doctor.surfaces.filter((s) => s.configured).length;
     console.log("");
     if (assessment.issues.length === 0) {
       console.log(`  ${ICON.ok}  ${pc3.green("You're all set.")}  ${pc3.dim(`OrgX is active across ${configuredCount} editor${configuredCount !== 1 ? "s" : ""}`)}`);
     } else {
       printDoctorReport(doctor, assessment);
-      if (!assessment.ok) {
+      if (verification.status === "error") {
         process.exitCode = 1;
       }
     }
@@ -3460,7 +5437,8 @@ async function main() {
       });
       spinner.text = "Verifying API key...";
       const result = await verifyAndPersistAuth(ready.key, {
-        ...opts.baseUrl !== void 0 ? { baseUrl: opts.baseUrl } : {}
+        ...opts.baseUrl !== void 0 ? { baseUrl: opts.baseUrl } : {},
+        ...opts.telemetrySource ? { telemetrySource: opts.telemetrySource } : {}
       });
       if (!("stored" in result)) {
         spinner.fail("Pairing completed but key was rejected");
@@ -3509,7 +5487,10 @@ async function main() {
     if (options.apiKey) {
       const spinner = createOrgxSpinner("Verifying OrgX API key");
       spinner.start();
-      const result = await verifyAndPersistAuth(options.apiKey, options);
+      const result = await verifyAndPersistAuth(options.apiKey, {
+        ...options,
+        telemetrySource: "manual_api_key"
+      });
       if (!("stored" in result)) {
         spinner.fail("OrgX API key verification failed");
         printAuthStatus(result.verification);
@@ -3528,13 +5509,17 @@ async function main() {
       ...options.baseUrl !== void 0 ? { baseUrl: options.baseUrl } : {},
       ...options.deviceName !== void 0 ? { deviceName: options.deviceName } : {},
       ...options.open !== void 0 ? { open: options.open } : {},
+      telemetrySource: "browser_pairing",
       timeout: options.timeout
     });
   });
   auth.command("set-key").description("Verify and persist a per-user OrgX API key for the wizard.").argument("<apiKey>", "per-user OrgX API key (oxk_...)").option("--base-url <url>", "OrgX base URL").action(async (apiKey, options) => {
     const spinner = createOrgxSpinner("Verifying OrgX API key");
     spinner.start();
-    const result = await verifyAndPersistAuth(apiKey, options);
+    const result = await verifyAndPersistAuth(apiKey, {
+      ...options,
+      telemetrySource: "manual_api_key"
+    });
     if (!("stored" in result)) {
       spinner.fail("OrgX API key verification failed");
       printAuthStatus(result.verification);
@@ -3583,6 +5568,41 @@ async function main() {
     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");
+    spinner.start();
+    const statuses = await listOrgxPluginStatuses();
+    spinner.stop();
+    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");
+    spinner.start();
+    const report = await installOrgxPlugins({ targets });
+    spinner.succeed("OrgX companion plugins processed");
+    printPluginMutationReport(report);
+    printPluginSkillOwnershipNote(report.results.map((result) => result.target));
+    await safeTrackWizardTelemetry("plugins_installed", {
+      changed_count: countPluginReportChanges(report),
+      command: "plugins:add",
+      requested_target_count: targets.length,
+      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");
+    spinner.start();
+    const report = await uninstallOrgxPlugins({ targets });
+    spinner.succeed("OrgX companion plugins removed");
+    printPluginMutationReport(report);
+    await safeTrackWizardTelemetry("plugins_removed", {
+      changed_count: countPluginReportChanges(report),
+      command: "plugins:remove",
+      requested_target_count: targets.length,
+      target_count: report.results.length
+    });
+  });
   const workspace = program.command("workspace").description("Inspect and create OrgX workspaces.");
   workspace.command("current").description("Show the current OrgX workspace.").action(async () => {
     const spinner = createOrgxSpinner("Loading current OrgX workspace");
@@ -3612,6 +5632,9 @@ async function main() {
       }
     );
     spinner.succeed("OrgX workspace created");
+    if (created.isDefault) {
+      persistContinuityDefaults({ workspace: created });
+    }
     printWorkspace(created);
     if (!created.isDefault) {
       console.log("");
@@ -3625,6 +5648,7 @@ async function main() {
     spinner.succeed(
       result.changed ? "Default OrgX workspace updated" : "OrgX workspace already set as default"
     );
+    persistContinuityDefaults({ workspace: result.workspace });
     printWorkspace(result.workspace);
   });
   program.command("doctor").description("Verify local OrgX surface config and optional remote setup status.").action(async () => {
@@ -3633,18 +5657,37 @@ async function main() {
     const report = await runDoctor();
     spinner.stop();
     const assessment = assessDoctorReport(report);
+    const verification = summarizeSetupVerification(assessment);
+    await safeTrackWizardTelemetry(
+      "doctor_ran",
+      buildDoctorTelemetryProperties(report, assessment, verification, {
+        command: "doctor"
+      })
+    );
     printDoctorReport(report, assessment);
-    if (!assessment.ok) {
+    if (verification.status === "error") {
       process.exitCode = 1;
     }
   });
   const skills = program.command("skills").description("Install OrgX rules and Claude skill packs.");
-  skills.command("add").description("Write Cursor and Claude OrgX rules and install OrgX Claude skill packs.").argument("[packs...]", "skill pack names or 'all'", ["all"]).action(async (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 pluginTargets = (await listOrgxPluginStatuses()).filter((status) => status.installed).map((status) => status.target);
     const spinner = createOrgxSpinner("Installing OrgX rules and skills");
     spinner.start();
-    const report = await installOrgxSkills({ skillNames: packs });
+    const report = await installOrgxSkills({
+      pluginTargets,
+      skillNames: packs
+    });
     spinner.succeed("OrgX rules and skills installed");
     printSkillInstallReport(report);
+    await safeTrackWizardTelemetry("skills_installed", {
+      changed_count: countSkillReportChanges(report),
+      command: "skills:add",
+      pack_count: report.packs.length,
+      plugin_managed_target_count: pluginTargets.length,
+      requested_pack_count: packs.length,
+      write_count: report.writes.length
+    });
   });
   await program.parseAsync(process.argv);
 }