@useorgx/wizard 0.1.45 → 0.1.47

package/dist/cli.js

@@ -3,7 +3,7 @@
 // src/cli.ts
 import * as clack from "@clack/prompts";
 import { spawnSync as spawnSync3 } from "child_process";
-import { readFileSync as readFileSync7 } from "fs";
+import { readFileSync as readFileSync8 } from "fs";
 import { hostname } from "os";
 import { resolve as resolve2 } from "path";
 import { Command } from "commander";
@@ -508,6 +508,31 @@ async function clearWizardAuth(authPath = ORGX_WIZARD_AUTH_PATH, options = {}) {
   return secretRemoved || fileRemoved;
 }
 
+// src/lib/network.ts
+var DEFAULT_REQUEST_TIMEOUT_MS = 12e3;
+function isTimeoutError(error) {
+  if (!(error instanceof Error)) return false;
+  if (error.name === "TimeoutError" || error.name === "AbortError") return true;
+  const message = error.message.toLowerCase();
+  return message.includes("aborted due to timeout") || message.includes("operation was aborted");
+}
+async function fetchWithRetry(url, init, options = {}) {
+  const timeoutMs = options.timeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+  const retries = options.retries ?? 1;
+  let lastError;
+  for (let attempt = 0; attempt <= retries; attempt++) {
+    try {
+      return await fetch(url, { ...init, signal: AbortSignal.timeout(timeoutMs) });
+    } catch (error) {
+      lastError = error;
+      if (!isTimeoutError(error) || attempt === retries) {
+        throw error;
+      }
+    }
+  }
+  throw lastError;
+}
+
 // src/lib/auth.ts
 function normalizeHost(value) {
   return value.trim().toLowerCase().replace(/^\[|\]$/g, "");
@@ -652,14 +677,13 @@ async function parseResponseBody(response) {
 async function verifyOrgxAuth(auth) {
   const url = buildOrgxApiUrl("/client/sync", auth.baseUrl);
   try {
-    const response = await fetch(url, {
+    const response = await fetchWithRetry(url, {
       method: "POST",
       headers: {
         Authorization: `Bearer ${auth.apiKey}`,
         "Content-Type": "application/json"
       },
-      body: "{}",
-      signal: AbortSignal.timeout(7e3)
+      body: "{}"
     });
     const data = await parseResponseBody(response);
     return {
@@ -1177,30 +1201,6 @@ function parseContinuityDefaults(value) {
   }
   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 parseFirstValueInitiative(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     return void 0;
@@ -1376,7 +1376,7 @@ function parseDailyBriefOnboarding(value) {
   };
 }
 function isSetupPromptKey(value) {
-  return value === "first_initiative" || value === "onboarding_task" || value === "agent_roster" || value === "setup_intent";
+  return value === "first_initiative" || value === "onboarding_task" || value === "agent_roster" || value === "local_skill_discovery" || value === "setup_intent";
 }
 function parseSetupPromptDecisionEntry(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
@@ -1421,7 +1421,6 @@ function createWizardState(now = (/* @__PURE__ */ new Date()).toISOString()) {
 function sanitizeWizardStateRecord(record) {
   const continuity = parseContinuityDefaults(record.continuity);
   const agentRoster = parseAgentRoster(record.agentRoster);
-  const demoInitiative = parseDemoInitiative(record.demoInitiative);
   const firstValueInitiative = parseFirstValueInitiative(record.firstValueInitiative);
   const onboardingTask = parseOnboardingTask(record.onboardingTask);
   const skillFiles = parseSkillFiles(record.skillFiles);
@@ -1434,7 +1433,6 @@ function sanitizeWizardStateRecord(record) {
     updatedAt: record.updatedAt.trim(),
     ...continuity ? { continuity } : {},
     ...agentRoster ? { agentRoster } : {},
-    ...demoInitiative ? { demoInitiative } : {},
     ...firstValueInitiative ? { firstValueInitiative } : {},
     ...onboardingTask ? { onboardingTask } : {},
     ...skillFiles ? { skillFiles } : {},
@@ -1457,8 +1455,6 @@ function readWizardState(statePath = ORGX_WIZARD_STATE_PATH) {
   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 firstValueInitiative = parseFirstValueInitiative(parsed.firstValueInitiative);
   if (firstValueInitiative !== void 0) {
     state.firstValueInitiative = firstValueInitiative;
@@ -1949,12 +1945,11 @@ function formatHttpError(status, body) {
 async function listWorkspaces(options = {}) {
   const auth = await requireOrgxAuth(options);
   const url = buildOrgxApiUrl("/entities?type=workspace&limit=100", auth.baseUrl);
-  const response = await fetch(url, {
+  const response = await fetchWithRetry(url, {
     method: "GET",
     headers: {
       Authorization: `Bearer ${auth.apiKey}`
-    },
-    signal: AbortSignal.timeout(7e3)
+    }
   });
   const body = await parseResponseBody2(response);
   if (!response.ok) {
@@ -1965,12 +1960,11 @@ async function listWorkspaces(options = {}) {
 async function getCurrentWorkspace(options = {}) {
   const auth = await requireOrgxAuth(options);
   const url = buildOrgxApiUrl("/v1/workspaces/current", auth.baseUrl);
-  const response = await fetch(url, {
+  const response = await fetchWithRetry(url, {
     method: "GET",
     headers: {
       Authorization: `Bearer ${auth.apiKey}`
-    },
-    signal: AbortSignal.timeout(7e3)
+    }
   });
   const body = await parseResponseBody2(response);
   if (response.ok) {
@@ -3215,8 +3209,8 @@ function encodeRepoPath2(value) {
   return value.split("/").filter((segment) => segment.length > 0).map((segment) => encodeURIComponent(segment)).join("/");
 }
 function isLikelyRepoFilePath(path) {
-  const basename4 = path.split("/").pop() ?? path;
-  return basename4.includes(".") && !/^\.[^./]+$/.test(basename4);
+  const basename5 = path.split("/").pop() ?? path;
+  return basename5.includes(".") && !/^\.[^./]+$/.test(basename5);
 }
 function buildContentsUrl2(spec, path) {
   const encodedPath = encodeRepoPath2(path);
@@ -4594,15 +4588,17 @@ function skippedOpenClawHealth() {
     details: []
   };
 }
-async function runDoctor() {
+async function runDoctor(options = {}) {
   const surfaces = listSurfaceStatuses();
   const openclawSurface = surfaces.find((surface) => surface.name === "openclaw");
-  const auth = await checkOrgxAuth();
-  const hostedMcp = await checkHostedMcpHealth();
-  const hostedMcpTool = await checkHostedMcpToolAccess();
-  const npmRegistry = await checkNpmRegistryHealth();
-  const workspace = await checkWorkspaceConnectivity();
-  const openclaw = openclawSurface?.detected ? await checkOpenClawHealth(openclawSurface.path) : skippedOpenClawHealth();
+  const [auth, hostedMcp, hostedMcpTool, npmRegistry, workspace, openclaw] = await Promise.all([
+    checkOrgxAuth(),
+    checkHostedMcpHealth(),
+    checkHostedMcpToolAccess(),
+    checkNpmRegistryHealth(),
+    options.cachedWorkspace ? Promise.resolve(options.cachedWorkspace) : checkWorkspaceConnectivity(),
+    openclawSurface?.detected ? checkOpenClawHealth(openclawSurface.path) : Promise.resolve(skippedOpenClawHealth())
+  ]);
   return { surfaces, auth, hostedMcp, hostedMcpTool, npmRegistry, workspace, openclaw };
 }
 function assessDoctorReport(report) {
@@ -4745,15 +4741,250 @@ function persistContinuityDefaults(seed = {}, statePath) {
   );
 }
 
+// src/lib/setup-workspace.ts
+var CREATE_WORKSPACE_VALUE = "__create_workspace__";
+var SKIP_WORKSPACE_VALUE = "__skip_workspace__";
+var REAUTH_WORKSPACE_VALUE = "__reauth_workspace__";
+function trimDescription(value) {
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function cancelResult(prompts, message = "Workspace bootstrap cancelled.") {
+  prompts.cancel(message);
+  return {
+    message,
+    status: "cancelled"
+  };
+}
+function buildWorkspaceLabel(workspace, currentWorkspaceId) {
+  const suffixes = [];
+  if (workspace.isDefault) {
+    suffixes.push("default");
+  }
+  if (workspace.id === currentWorkspaceId) {
+    suffixes.push("current");
+  }
+  if (suffixes.length === 0) {
+    return workspace.name;
+  }
+  return `${workspace.name} (${suffixes.join(", ")})`;
+}
+function buildWorkspaceSelectOptions(workspaces, currentWorkspaceId) {
+  const options = workspaces.map((workspace) => ({
+    value: workspace.id,
+    label: buildWorkspaceLabel(workspace, currentWorkspaceId),
+    ...workspace.description ? { hint: workspace.description } : {}
+  }));
+  options.push(
+    {
+      value: CREATE_WORKSPACE_VALUE,
+      label: "Create a new workspace",
+      hint: "Name it here and set it as the default for this machine."
+    },
+    {
+      value: SKIP_WORKSPACE_VALUE,
+      label: "Skip for now",
+      hint: "Leave workspace selection unchanged and finish setup."
+    }
+  );
+  return options;
+}
+async function promptForWorkspaceName(prompts) {
+  return prompts.text({
+    message: "Workspace name",
+    placeholder: "Founders",
+    validate(value) {
+      if (!value || value.trim().length === 0) {
+        return "Workspace name is required.";
+      }
+      return void 0;
+    }
+  });
+}
+async function promptForWorkspaceDescription(prompts) {
+  return prompts.text({
+    message: "Workspace description",
+    placeholder: "Optional"
+  });
+}
+async function createAndSelectWorkspace(client, prompts) {
+  const name = await promptForWorkspaceName(prompts);
+  if (prompts.isCancel(name)) {
+    return cancelResult(prompts);
+  }
+  if (typeof name !== "string") {
+    return cancelResult(prompts);
+  }
+  const description = await promptForWorkspaceDescription(prompts);
+  if (prompts.isCancel(description)) {
+    return cancelResult(prompts);
+  }
+  if (typeof description !== "string") {
+    return cancelResult(prompts);
+  }
+  const trimmedDescription = trimDescription(description);
+  const createWorkspaceInput = trimmedDescription ? { name, description: trimmedDescription } : { name };
+  const created = await client.createWorkspace(createWorkspaceInput);
+  if (created.isDefault) {
+    return {
+      created: true,
+      defaultChanged: false,
+      message: `Created "${created.name}" and it is already the default OrgX workspace.`,
+      status: "updated",
+      workspace: created
+    };
+  }
+  const promoted = await client.setDefaultWorkspace({ id: created.id });
+  return {
+    created: true,
+    defaultChanged: promoted.changed,
+    message: `Created "${promoted.workspace.name}" and set it as the default OrgX workspace.`,
+    status: "updated",
+    workspace: promoted.workspace
+  };
+}
+async function runWorkspaceSetup(client, prompts, options) {
+  if (!options.interactive) {
+    return {
+      message: "Interactive workspace bootstrap skipped because this shell is not attached to a TTY.",
+      status: "skipped"
+    };
+  }
+  const workspaces = await client.listWorkspaces();
+  const currentWorkspace = workspaces.length > 0 ? await client.getCurrentWorkspace().catch(() => workspaces.find((workspace) => workspace.isDefault) ?? null) : null;
+  if (workspaces.length === 0) {
+    const action = await prompts.select({
+      message: "OrgX authenticated, but returned 0 workspaces for this key. How should setup proceed?",
+      options: [
+        {
+          value: REAUTH_WORKSPACE_VALUE,
+          label: "Re-authenticate (recommended if you expected workspaces)",
+          hint: "Run `wizard auth login` to re-link via OAuth if your API key is bound to a different user identity."
+        },
+        {
+          value: CREATE_WORKSPACE_VALUE,
+          label: "Create a new workspace",
+          hint: "Use this only for a truly new account \u2014 this will fork data if your key is misbound."
+        },
+        {
+          value: SKIP_WORKSPACE_VALUE,
+          label: "Skip for now",
+          hint: "Finish surface setup without touching workspaces."
+        }
+      ],
+      initialValue: REAUTH_WORKSPACE_VALUE
+    });
+    if (prompts.isCancel(action)) {
+      return cancelResult(prompts);
+    }
+    if (action === REAUTH_WORKSPACE_VALUE) {
+      return {
+        message: "Re-authentication requested. Run `wizard auth login`, then rerun `wizard setup`.",
+        status: "reauth_requested"
+      };
+    }
+    if (action === SKIP_WORKSPACE_VALUE) {
+      return {
+        message: "Workspace bootstrap skipped.",
+        status: "skipped"
+      };
+    }
+    return createAndSelectWorkspace(client, prompts);
+  }
+  if (options.skipIfConfigured && currentWorkspace) {
+    return {
+      defaultChanged: false,
+      message: `Using "${currentWorkspace.name}" as the default OrgX workspace.`,
+      status: "unchanged",
+      workspace: currentWorkspace
+    };
+  }
+  const initialWorkspaceId = currentWorkspace?.id ?? workspaces.find((workspace) => workspace.isDefault)?.id ?? workspaces[0]?.id;
+  const selected = await prompts.select({
+    message: "Choose the OrgX workspace this machine should use by default.",
+    options: buildWorkspaceSelectOptions(
+      workspaces,
+      currentWorkspace?.id ?? workspaces.find((workspace) => workspace.isDefault)?.id
+    ),
+    ...initialWorkspaceId ? { initialValue: initialWorkspaceId } : {}
+  });
+  if (prompts.isCancel(selected)) {
+    return cancelResult(prompts);
+  }
+  if (typeof selected !== "string") {
+    return cancelResult(prompts);
+  }
+  if (selected === SKIP_WORKSPACE_VALUE) {
+    return {
+      message: "Workspace bootstrap skipped.",
+      status: "skipped",
+      ...currentWorkspace ? { workspace: currentWorkspace } : {}
+    };
+  }
+  if (selected === CREATE_WORKSPACE_VALUE) {
+    return createAndSelectWorkspace(client, prompts);
+  }
+  const chosenWorkspace = workspaces.find((workspace) => workspace.id === selected);
+  if (!chosenWorkspace) {
+    throw new Error(`Selected workspace ${selected} is no longer available.`);
+  }
+  if (chosenWorkspace.isDefault) {
+    return {
+      defaultChanged: false,
+      message: `"${chosenWorkspace.name}" is already the default OrgX workspace.`,
+      status: "unchanged",
+      workspace: chosenWorkspace
+    };
+  }
+  const promoted = await client.setDefaultWorkspace({ id: chosenWorkspace.id });
+  return {
+    defaultChanged: promoted.changed,
+    message: `Set "${promoted.workspace.name}" as the default OrgX workspace.`,
+    status: promoted.changed ? "updated" : "unchanged",
+    workspace: promoted.workspace
+  };
+}
+
+// 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;
+  let workspace = await getCurrentWorkspace().catch(() => null);
+  if (workspace || options.interactive) {
+    workspaceSetup = await runWorkspaceSetup(
+      {
+        createWorkspace,
+        getCurrentWorkspace,
+        listWorkspaces,
+        setDefaultWorkspace
+      },
+      prompts,
+      options
+    );
+    if (workspaceSetup.status === "cancelled") {
+      return workspaceSetup;
+    }
+    workspace = workspaceSetup.workspace ?? workspace ?? await getCurrentWorkspace().catch(() => null);
+  }
+  const continuity = persistContinuityDefaults({
+    statuses: listSurfaceStatuses(),
+    workspace
+  });
+  return {
+    continuity,
+    skillReport,
+    surfaceResults,
+    workspace,
+    ...workspaceSetup ? { workspaceSetup } : {}
+  };
+}
+
 // 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.";
 var ONBOARDING_WORKSTREAM_TITLE = "OrgX onboarding";
@@ -4799,36 +5030,6 @@ function parseInitiative(payload) {
     ...typeof entity.summary === "string" && entity.summary.trim().length > 0 ? { summary: entity.summary.trim() } : {}
   };
 }
-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() : "";
@@ -4852,23 +5053,6 @@ function parseWorkstream(payload) {
   }
   return { id, title };
 }
-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,
-    workspaceId: workspace.id,
-    workspaceName: workspace.name
-  };
-}
 function toOnboardingTaskRecord(task, workspace, options = {}) {
   return {
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -4921,27 +5105,6 @@ async function createEntity(type, body, parse2, options = {}) {
   }
   return parse2(responseBody);
 }
-async function updateEntity(type, id, body, parse2, options = {}) {
-  const auth = await requireOrgxAuth2(options);
-  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));
   parsed.pathname = `/live/${initiativeId}`;
@@ -4949,48 +5112,6 @@ function buildLiveUrl(baseUrl, initiativeId) {
   parsed.hash = "";
   return parsed.toString();
 }
-async function createFounderDemoDecision(initiative, workspaceId, options = {}) {
-  return createEntity(
-    "decision",
-    {
-      initiative_id: initiative.id,
-      summary: FOUNDER_DEMO_DECISION_SUMMARY,
-      title: FOUNDER_DEMO_DECISION_TITLE,
-      workspace_id: workspaceId
-    },
-    parseDecision,
-    options
-  );
-}
-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) {
@@ -5008,52 +5129,6 @@ async function createInitiative(input, options = {}) {
     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 {
-    artifact,
-    created: !matchingRecord,
-    decision,
-    initiative,
-    liveUrl
-  };
-}
 async function ensureFirstValueInitiative(workspace, options = {}) {
   const existingRecord = readWizardState(options.statePath)?.firstValueInitiative;
   const matchingRecord = existingRecord?.workspaceId === workspace.id ? existingRecord : void 0;
@@ -5143,253 +5218,206 @@ async function ensureOnboardingTask(workspace, options = {}) {
   );
   return task;
 }
-
-// src/lib/setup-workspace.ts
-var CREATE_WORKSPACE_VALUE = "__create_workspace__";
-var SKIP_WORKSPACE_VALUE = "__skip_workspace__";
-var REAUTH_WORKSPACE_VALUE = "__reauth_workspace__";
-function trimDescription(value) {
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : void 0;
-}
-function cancelResult(prompts, message = "Workspace bootstrap cancelled.") {
-  prompts.cancel(message);
-  return {
-    message,
-    status: "cancelled"
-  };
-}
-function buildWorkspaceLabel(workspace, currentWorkspaceId) {
-  const suffixes = [];
-  if (workspace.isDefault) {
-    suffixes.push("default");
-  }
-  if (workspace.id === currentWorkspaceId) {
-    suffixes.push("current");
-  }
-  if (suffixes.length === 0) {
-    return workspace.name;
-  }
-  return `${workspace.name} (${suffixes.join(", ")})`;
-}
-function buildWorkspaceSelectOptions(workspaces, currentWorkspaceId) {
-  const options = workspaces.map((workspace) => ({
-    value: workspace.id,
-    label: buildWorkspaceLabel(workspace, currentWorkspaceId),
-    ...workspace.description ? { hint: workspace.description } : {}
-  }));
-  options.push(
-    {
-      value: CREATE_WORKSPACE_VALUE,
-      label: "Create a new workspace",
-      hint: "Name it here and set it as the default for this machine."
-    },
-    {
-      value: SKIP_WORKSPACE_VALUE,
-      label: "Skip for now",
-      hint: "Leave workspace selection unchanged and finish setup."
-    }
-  );
-  return options;
-}
-async function promptForWorkspaceName(prompts) {
-  return prompts.text({
-    message: "Workspace name",
-    placeholder: "Founders",
-    validate(value) {
-      if (!value || value.trim().length === 0) {
-        return "Workspace name is required.";
-      }
-      return void 0;
-    }
-  });
-}
-async function promptForWorkspaceDescription(prompts) {
-  return prompts.text({
-    message: "Workspace description",
-    placeholder: "Optional"
-  });
-}
-async function createAndSelectWorkspace(client, prompts) {
-  const name = await promptForWorkspaceName(prompts);
-  if (prompts.isCancel(name)) {
-    return cancelResult(prompts);
-  }
-  if (typeof name !== "string") {
-    return cancelResult(prompts);
-  }
-  const description = await promptForWorkspaceDescription(prompts);
-  if (prompts.isCancel(description)) {
-    return cancelResult(prompts);
-  }
-  if (typeof description !== "string") {
-    return cancelResult(prompts);
-  }
-  const trimmedDescription = trimDescription(description);
-  const createWorkspaceInput = trimmedDescription ? { name, description: trimmedDescription } : { name };
-  const created = await client.createWorkspace(createWorkspaceInput);
-  if (created.isDefault) {
-    return {
-      created: true,
-      defaultChanged: false,
-      message: `Created "${created.name}" and it is already the default OrgX workspace.`,
-      status: "updated",
-      workspace: created
-    };
-  }
-  const promoted = await client.setDefaultWorkspace({ id: created.id });
-  return {
-    created: true,
-    defaultChanged: promoted.changed,
-    message: `Created "${promoted.workspace.name}" and set it as the default OrgX workspace.`,
-    status: "updated",
-    workspace: promoted.workspace
-  };
-}
-async function runWorkspaceSetup(client, prompts, options) {
-  if (!options.interactive) {
-    return {
-      message: "Interactive workspace bootstrap skipped because this shell is not attached to a TTY.",
-      status: "skipped"
-    };
-  }
-  const workspaces = await client.listWorkspaces();
-  const currentWorkspace = workspaces.length > 0 ? await client.getCurrentWorkspace().catch(() => workspaces.find((workspace) => workspace.isDefault) ?? null) : null;
-  if (workspaces.length === 0) {
-    const action = await prompts.select({
-      message: "OrgX authenticated, but returned 0 workspaces for this key. How should setup proceed?",
-      options: [
-        {
-          value: REAUTH_WORKSPACE_VALUE,
-          label: "Re-authenticate (recommended if you expected workspaces)",
-          hint: "Run `wizard auth login` to re-link via OAuth if your API key is bound to a different user identity."
-        },
-        {
-          value: CREATE_WORKSPACE_VALUE,
-          label: "Create a new workspace",
-          hint: "Use this only for a truly new account \u2014 this will fork data if your key is misbound."
-        },
-        {
-          value: SKIP_WORKSPACE_VALUE,
-          label: "Skip for now",
-          hint: "Finish surface setup without touching workspaces."
-        }
-      ],
-      initialValue: REAUTH_WORKSPACE_VALUE
-    });
-    if (prompts.isCancel(action)) {
-      return cancelResult(prompts);
-    }
-    if (action === REAUTH_WORKSPACE_VALUE) {
-      return {
-        message: "Re-authentication requested. Run `wizard auth login`, then rerun `wizard setup`.",
-        status: "reauth_requested"
-      };
+
+// src/lib/local-skill-discovery.ts
+import { createHash as createHash3 } from "crypto";
+import { readdirSync as readdirSync3, readFileSync as readFileSync3, statSync as statSync3 } from "fs";
+import { basename as basename2, join as join4, relative as relative2 } from "path";
+var DEFAULT_MAX_BYTES = 48e3;
+var DEFAULT_LIMIT = 12;
+var IGNORED_DIRS = /* @__PURE__ */ new Set([".git", ".next", ".turbo", "build", "dist", "node_modules"]);
+var LOCAL_SKILL_SOURCES = ["opencode", "claude", "codex", "agents", "workspace"];
+var DOMAIN_KEYWORDS = [
+  { domain: "engineering", pattern: /\b(eval|benchmark|test|ci|code|github|repo|runtime|api|llm|model)\b/i },
+  { domain: "product", pattern: /\b(customer|workflow|roadmap|prd|user|adoption|value|requirements?)\b/i },
+  { domain: "operations", pattern: /\b(runbook|incident|sla|dashboard|superset|metric|monitor|ops)\b/i },
+  { domain: "design", pattern: /\b(ui|ux|design|accessibility|component|visual)\b/i },
+  { domain: "marketing", pattern: /\b(launch|campaign|positioning|gtm|content|story)\b/i },
+  { domain: "sales", pattern: /\b(deal|pipeline|prospect|meddic|outreach|buyer)\b/i }
+];
+function hash(value, length = 10) {
+  return createHash3("sha256").update(value).digest("hex").slice(0, length);
+}
+function safeStat(path) {
+  try {
+    return statSync3(path);
+  } catch {
+    return null;
+  }
+}
+function defaultRoots(input) {
+  return {
+    agents: [join4(input.home, ".agents", "skills")],
+    claude: [join4(input.home, ".claude", "skills"), join4(input.cwd, ".claude", "skills")],
+    codex: [join4(input.home, ".codex", "skills"), join4(input.cwd, ".codex", "skills")],
+    opencode: [
+      join4(input.home, ".opencode", "skills"),
+      join4(input.home, ".config", "opencode", "skills"),
+      join4(input.home, "Library", "Application Support", "opencode", "skills"),
+      join4(input.cwd, ".opencode", "skills")
+    ],
+    workspace: [
+      join4(input.cwd, "skills"),
+      join4(input.cwd, ".agents", "skills"),
+      join4(input.cwd, ".orgx", "skills")
+    ]
+  };
+}
+function walkSkillFiles(root, maxFiles = 200) {
+  const rootStats = safeStat(root);
+  if (!rootStats) return [];
+  if (rootStats.isFile()) return [root];
+  if (!rootStats.isDirectory()) return [];
+  const files = [];
+  const stack = [root];
+  while (stack.length > 0 && files.length < maxFiles) {
+    const current = stack.pop();
+    if (!current) continue;
+    let entries;
+    try {
+      entries = readdirSync3(current, { withFileTypes: true });
+    } catch {
+      continue;
     }
-    if (action === SKIP_WORKSPACE_VALUE) {
-      return {
-        message: "Workspace bootstrap skipped.",
-        status: "skipped"
-      };
+    for (const entry of entries) {
+      if (IGNORED_DIRS.has(entry.name)) continue;
+      const path = join4(current, entry.name);
+      if (entry.isDirectory()) {
+        stack.push(path);
+      } else if (entry.isFile() && /\.(md|mdc|txt)$/i.test(entry.name)) {
+        files.push(path);
+      }
     }
-    return createAndSelectWorkspace(client, prompts);
-  }
-  if (options.skipIfConfigured && currentWorkspace) {
-    return {
-      defaultChanged: false,
-      message: `Using "${currentWorkspace.name}" as the default OrgX workspace.`,
-      status: "unchanged",
-      workspace: currentWorkspace
-    };
-  }
-  const initialWorkspaceId = currentWorkspace?.id ?? workspaces.find((workspace) => workspace.isDefault)?.id ?? workspaces[0]?.id;
-  const selected = await prompts.select({
-    message: "Choose the OrgX workspace this machine should use by default.",
-    options: buildWorkspaceSelectOptions(
-      workspaces,
-      currentWorkspace?.id ?? workspaces.find((workspace) => workspace.isDefault)?.id
-    ),
-    ...initialWorkspaceId ? { initialValue: initialWorkspaceId } : {}
-  });
-  if (prompts.isCancel(selected)) {
-    return cancelResult(prompts);
   }
-  if (typeof selected !== "string") {
-    return cancelResult(prompts);
+  return files;
+}
+function readWindow(path, maxBytes) {
+  const stats = safeStat(path);
+  if (!stats?.isFile() || stats.size === 0) return null;
+  try {
+    const text2 = readFileSync3(path, "utf8");
+    return text2.slice(0, maxBytes);
+  } catch {
+    return null;
   }
-  if (selected === SKIP_WORKSPACE_VALUE) {
-    return {
-      message: "Workspace bootstrap skipped.",
-      status: "skipped",
-      ...currentWorkspace ? { workspace: currentWorkspace } : {}
-    };
+}
+function titleFrom(path, text2) {
+  const heading = text2.match(/^#\s+(.+)$/m)?.[1]?.trim();
+  if (heading) return heading.slice(0, 120);
+  return basename2(path).replace(/\.(md|mdc|txt)$/i, "").replace(/[-_]+/g, " ");
+}
+function snippetFrom(text2) {
+  const lines = text2.split(/\r?\n/).map((line) => line.trim()).filter((line) => line && !line.startsWith("---") && !/^#+\s/.test(line));
+  return lines.slice(0, 4).join(" ").replace(/\s+/g, " ").slice(0, 420);
+}
+function tokenize(value) {
+  return value.toLowerCase().split(/[^a-z0-9]+/).filter((token) => token.length >= 3);
+}
+function scoreCandidate(text2, context, source) {
+  const haystack = text2.toLowerCase();
+  const contextTokens = [...new Set(tokenize(context))];
+  const contextHits = contextTokens.filter((token) => haystack.includes(token)).length;
+  const explicitSkillSignal = /\b(skill|agent|workflow|instruction|rule|prompt|playbook)\b/i.test(text2) ? 2 : 0;
+  const sourceBoost = source === "opencode" ? 2 : source === "workspace" ? 1 : 0;
+  const score = contextHits * 3 + explicitSkillSignal + sourceBoost;
+  const reasonParts = [
+    contextHits > 0 ? `${contextHits} context match${contextHits === 1 ? "" : "es"}` : "local skill file",
+    sourceBoost > 0 ? `${source} source` : ""
+  ].filter(Boolean);
+  return { reason: reasonParts.join("; "), score };
+}
+function inferDomains(text2, context) {
+  const joined = `${text2}
+${context}`;
+  const domains = DOMAIN_KEYWORDS.filter((entry) => entry.pattern.test(joined)).map((entry) => entry.domain);
+  return domains.length > 0 ? [...new Set(domains)] : ["orchestrator"];
+}
+function parseLocalSkillSources(value) {
+  if (!value?.trim() || value.trim().toLowerCase() === "all") {
+    return [...LOCAL_SKILL_SOURCES];
   }
-  if (selected === CREATE_WORKSPACE_VALUE) {
-    return createAndSelectWorkspace(client, prompts);
+  const requested = value.split(",").map((item) => item.trim().toLowerCase()).filter(Boolean);
+  const invalid = requested.filter((source) => !LOCAL_SKILL_SOURCES.includes(source));
+  if (invalid.length > 0) {
+    throw new Error(`Unsupported local skill source: ${invalid.join(", ")}. Use ${LOCAL_SKILL_SOURCES.join(", ")}, or all.`);
   }
-  const chosenWorkspace = workspaces.find((workspace) => workspace.id === selected);
-  if (!chosenWorkspace) {
-    throw new Error(`Selected workspace ${selected} is no longer available.`);
+  return [...new Set(requested)];
+}
+function discoverLocalSkills(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const home = options.home ?? process.env.HOME ?? "";
+  const sources = options.sources ?? [...LOCAL_SKILL_SOURCES];
+  const maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
+  const context = options.context?.trim() ?? "";
+  const roots = defaultRoots({ cwd, home });
+  for (const [source, overrides] of Object.entries(options.roots ?? {})) {
+    roots[source] = overrides;
   }
-  if (chosenWorkspace.isDefault) {
-    return {
-      defaultChanged: false,
-      message: `"${chosenWorkspace.name}" is already the default OrgX workspace.`,
-      status: "unchanged",
-      workspace: chosenWorkspace
-    };
+  const seen = /* @__PURE__ */ new Set();
+  const candidates = [];
+  for (const source of sources) {
+    for (const root of roots[source] ?? []) {
+      for (const path of walkSkillFiles(root)) {
+        if (seen.has(path)) continue;
+        seen.add(path);
+        const text2 = readWindow(path, maxBytes);
+        if (!text2 || /ORGX SKILL COMPOSED v1/.test(text2)) continue;
+        const title = titleFrom(path, text2);
+        const snippet = snippetFrom(text2);
+        const scored = scoreCandidate(`${title}
+${snippet}
+${text2}`, context, source);
+        candidates.push({
+          agentDomains: inferDomains(`${title}
+${snippet}`, context),
+          id: `${source}-${hash(path)}`,
+          path,
+          reason: scored.reason,
+          score: scored.score,
+          snippet,
+          source,
+          title
+        });
+      }
+    }
   }
-  const promoted = await client.setDefaultWorkspace({ id: chosenWorkspace.id });
-  return {
-    defaultChanged: promoted.changed,
-    message: `Set "${promoted.workspace.name}" as the default OrgX workspace.`,
-    status: promoted.changed ? "updated" : "unchanged",
-    workspace: promoted.workspace
-  };
+  return candidates.sort((left, right) => right.score - left.score || left.title.localeCompare(right.title)).slice(0, Math.max(1, options.limit ?? DEFAULT_LIMIT));
 }
-
-// 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;
-  let workspace = await getCurrentWorkspace().catch(() => null);
-  if (workspace || options.interactive) {
-    workspaceSetup = await runWorkspaceSetup(
-      {
-        createWorkspace,
-        getCurrentWorkspace,
-        listWorkspaces,
-        setDefaultWorkspace
-      },
-      prompts,
-      options
-    );
-    if (workspaceSetup.status === "cancelled") {
-      return workspaceSetup;
+function selectLocalSkillCandidates(candidates, selection) {
+  const wanted = selection.split(",").map((item) => item.trim()).filter(Boolean);
+  const selected = [];
+  for (const item of wanted) {
+    const byIndex = /^\d+$/.test(item) ? candidates[Number(item) - 1] : void 0;
+    const byId = candidates.find((candidate) => candidate.id === item);
+    const match = byIndex ?? byId;
+    if (!match) {
+      throw new Error(`No local skill candidate matched '${item}'.`);
     }
-    workspace = workspaceSetup.workspace ?? workspace ?? await getCurrentWorkspace().catch(() => null);
+    selected.push(match);
   }
-  const continuity = persistContinuityDefaults({
-    statuses: listSurfaceStatuses(),
-    workspace
-  });
-  let demoInitiative;
-  if (workspace) {
-    demoInitiative = await ensureFounderDemoInitiative(workspace);
+  return [...new Map(selected.map((candidate) => [candidate.id, candidate])).values()];
+}
+function buildLocalSkillExtensionContent(candidates, context) {
+  const lines = [
+    "# Local Skill Preferences",
+    "",
+    "Use these opt-in local preferences when they are relevant to the current OrgX initiative. Do not override explicit user instructions or repo guardrails."
+  ];
+  const trimmedContext = context?.trim();
+  if (trimmedContext) {
+    lines.push("", `Context: ${trimmedContext}`);
   }
-  return {
-    continuity,
-    ...demoInitiative ? { demoInitiative } : {},
-    skillReport,
-    surfaceResults,
-    workspace,
-    ...workspaceSetup ? { workspaceSetup } : {}
-  };
+  for (const candidate of candidates) {
+    lines.push(
+      "",
+      `## ${candidate.title}`,
+      "",
+      `- Source: ${candidate.source} (${relative2(process.cwd(), candidate.path)})`,
+      `- Suggested agents: ${candidate.agentDomains.join(", ")}`,
+      `- Preserve: ${candidate.snippet || "local workflow preference from this skill file."}`
+    );
+  }
+  return lines.join("\n");
 }
 
 // src/lib/mutation-output.ts
@@ -5406,6 +5434,9 @@ var HOSTED_MCP_OUTAGE_TITLE = "Hosted OrgX MCP is unreachable.";
 function getSetupVerificationHeadline(summary) {
   switch (summary.status) {
     case "degraded":
+      if (summary.transientTimeouts) {
+        return "OrgX servers were slow to respond \u2014 setup applied, but the final health check timed out. Re-run `wizard doctor` in a moment to confirm.";
+      }
       return "Hosted OrgX MCP is down; local setup can still continue.";
     case "error":
       return "Issues detected";
@@ -5415,18 +5446,50 @@ function getSetupVerificationHeadline(summary) {
       return "All systems ready.";
   }
 }
-function summarizeSetupVerification(assessment) {
+function isTimeoutErrorString(value) {
+  if (!value) return false;
+  return isTimeoutError(new Error(value));
+}
+function reportErrorsAreOnlyTimeouts(report) {
+  if (!report) return false;
+  const authTimedOut = !report.auth.ok && !report.auth.skipped && isTimeoutErrorString(report.auth.error);
+  const workspaceTimedOut = !report.workspace.ok && !report.workspace.skipped && isTimeoutErrorString(report.workspace.error);
+  const reachableServicesOk = (report.hostedMcp.skipped || report.hostedMcp.ok) && (report.openclaw.skipped || report.openclaw.ok);
+  return reachableServicesOk && (authTimedOut || workspaceTimedOut);
+}
+function summarizeSetupVerification(assessment, report) {
   const errors = assessment.issues.filter((issue) => issue.level === "error");
   if (errors.length === 0) {
     return {
       hostedMcpDegraded: false,
+      transientTimeouts: false,
       status: assessment.issues.length > 0 ? "warning" : "ok"
     };
   }
   const hostedMcpDegraded = errors.every((issue) => issue.title === HOSTED_MCP_OUTAGE_TITLE);
+  if (hostedMcpDegraded) {
+    return {
+      hostedMcpDegraded: true,
+      transientTimeouts: false,
+      status: "degraded"
+    };
+  }
+  const authOrWorkspaceTitles = /* @__PURE__ */ new Set([
+    "OrgX user auth could not be verified.",
+    "Current workspace lookup failed."
+  ]);
+  const onlyAuthOrWorkspaceErrors = errors.every((issue) => authOrWorkspaceTitles.has(issue.title));
+  if (onlyAuthOrWorkspaceErrors && reportErrorsAreOnlyTimeouts(report)) {
+    return {
+      hostedMcpDegraded: false,
+      transientTimeouts: true,
+      status: "degraded"
+    };
+  }
   return {
-    hostedMcpDegraded,
-    status: hostedMcpDegraded ? "degraded" : "error"
+    hostedMcpDegraded: false,
+    transientTimeouts: false,
+    status: "error"
   };
 }
 
@@ -5468,16 +5531,6 @@ function buildAgentRosterTelemetryProperties(input, base = {}) {
     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 buildFirstValueInitiativeTelemetryProperties(result, base = {}) {
   return withBaseProperties(
     {
@@ -5500,6 +5553,7 @@ function buildDoctorTelemetryProperties(report, assessment, verification, base =
       hosted_mcp_degraded: verification.hostedMcpDegraded,
       hosted_mcp_ok: report.hostedMcp.ok,
       hosted_mcp_tool_ok: report.hostedMcpTool.ok,
+      transient_timeouts: verification.transientTimeouts,
       issue_count: assessment.issues.length,
       openclaw_available: !report.openclaw.skipped,
       openclaw_ok: report.openclaw.ok,
@@ -5913,6 +5967,40 @@ function normalizeHotkey(input) {
   }
 }
 
+// src/lib/setup-profiles.ts
+var SETUP_PROFILES = {
+  "local-ai-workflow": {
+    id: "local-ai-workflow",
+    label: "Local AI workflow",
+    firstInitiativeTitle: "Make local AI work visible and shippable",
+    firstInitiativeSummary: [
+      "First OrgX initiative tailored for a local AI-assisted workflow.",
+      "Use local AI-session evidence, Git/GitHub proof, and existing project context to create a live work graph, a concrete onboarding task, and a path to cloud execution once GitHub is connected."
+    ].join(" "),
+    handoffPrompt: "Use OrgX to continue this local AI-workflow initiative. Start with the onboarding task, inspect local AI-client and GitHub proof, preserve selected local skills, and show the next action plus the cloud handoff once GitHub is connected.",
+    localProofCommand: "orgx-wizard sessions reconcile --from opencode,github --public-share --yes",
+    skillDiscoveryCommand: `orgx-wizard skills discover-local --from opencode,claude,codex,workspace --context "Describe this person's domain, tools, and workflow"`
+  }
+};
+function resolveSetupProfile(id) {
+  const normalized = id?.trim().toLowerCase();
+  if (!normalized) return null;
+  return SETUP_PROFILES[normalized] ?? null;
+}
+function supportedSetupProfileIds() {
+  return Object.keys(SETUP_PROFILES).sort();
+}
+function buildProfileSummary(profile, context) {
+  const trimmedContext = context?.trim();
+  if (!trimmedContext) return profile.firstInitiativeSummary;
+  return `${profile.firstInitiativeSummary} Context: ${trimmedContext}`;
+}
+function buildProfileHandoffPrompt(profile, fallbackPrompt, context) {
+  if (!profile) return fallbackPrompt;
+  const trimmedContext = context?.trim();
+  return trimmedContext ? `${profile.handoffPrompt} Context: ${trimmedContext}` : profile.handoffPrompt;
+}
+
 // src/lib/daily-brief-onboarding.ts
 function extractErrorHint(body) {
   if (!body) return null;
@@ -6222,8 +6310,8 @@ async function fetchOnboardingState(auth) {
 }
 
 // src/lib/ai-session-import.ts
-import { existsSync as existsSync5, readdirSync as readdirSync3, readFileSync as readFileSync3, statSync as statSync3 } from "fs";
-import { basename as basename2, join as join4, relative as relative2 } from "path";
+import { existsSync as existsSync6, readdirSync as readdirSync4, readFileSync as readFileSync4, statSync as statSync4 } from "fs";
+import { basename as basename3, join as join5, relative as relative3 } from "path";
 var AI_SESSION_SOURCES = ["codex", "claude"];
 var DEFAULT_LIMIT_PER_SOURCE = 3;
 var DEFAULT_SINCE_DAYS = 30;
@@ -6376,7 +6464,7 @@ function keepAuditRelevantLines(text2) {
   return text2.split(/\r?\n/).map((line) => normalizeAuditRelevantLine(line)).filter((line) => Boolean(line));
 }
 function collectJsonlFiles(root, source) {
-  if (!existsSync5(root)) return [];
+  if (!existsSync6(root)) return [];
   const files = [];
   const stack = [root];
   while (stack.length > 0) {
@@ -6384,15 +6472,15 @@ function collectJsonlFiles(root, source) {
     if (!current) continue;
     let entries;
     try {
-      entries = readdirSync3(current);
+      entries = readdirSync4(current);
     } catch {
       continue;
     }
     for (const entry of entries) {
-      const path = join4(current, entry);
+      const path = join5(current, entry);
       let stats;
       try {
-        stats = statSync3(path);
+        stats = statSync4(path);
       } catch {
         continue;
       }
@@ -6410,13 +6498,13 @@ function collectJsonlFiles(root, source) {
 function readSessionImport(candidate, root, options) {
   let stats;
   try {
-    stats = statSync3(candidate.path);
+    stats = statSync4(candidate.path);
   } catch {
     return null;
   }
   if (stats.size > options.maxBytesPerFile) return null;
   const extractor = candidate.source === "codex" ? extractCodexMessageText : extractClaudeMessageText;
-  const lines = readFileSync3(candidate.path, "utf8").split(/\r?\n/);
+  const lines = readFileSync4(candidate.path, "utf8").split(/\r?\n/);
   const relevantLines = [];
   let messageCount = 0;
   for (const line of lines) {
@@ -6428,10 +6516,10 @@ function readSessionImport(candidate, root, options) {
   }
   const deduped = [...new Set(relevantLines)].slice(0, 80);
   if (deduped.length === 0) return null;
-  const relativePath = relative2(root, candidate.path);
+  const relativePath = relative3(root, candidate.path);
   return {
     import: {
-      sourceId: `${candidate.source}:${basename2(candidate.path, ".jsonl")}`,
+      sourceId: `${candidate.source}:${basename3(candidate.path, ".jsonl")}`,
       sourceLabel: `${candidate.source === "codex" ? "Codex" : "Claude"} session ${relativePath}`,
       metadata: {
         bytes: stats.size,
@@ -6501,11 +6589,11 @@ function loadAiSessionImports(options) {
 }
 
 // src/lib/work-graph-source-adapters.ts
-import { createHash as createHash3 } from "crypto";
+import { createHash as createHash4 } from "crypto";
 import { execFileSync } from "child_process";
-import { closeSync, existsSync as existsSync6, openSync, readFileSync as readFileSync4, readdirSync as readdirSync4, readSync, statSync as statSync4 } from "fs";
+import { closeSync, existsSync as existsSync7, openSync, readFileSync as readFileSync5, readdirSync as readdirSync5, readSync, statSync as statSync5 } from "fs";
 import { homedir as homedir2 } from "os";
-import { basename as basename3, join as join5, resolve } from "path";
+import { basename as basename4, join as join6, resolve } from "path";
 var CLIENT_SOURCES = ["claude_code", "codex", "opencode", "goose", "cursor", "github", "slack"];
 var DEFAULT_LIMIT_PER_SOURCE2 = 8;
 var DEFAULT_SINCE_DAYS2 = 45;
@@ -6524,21 +6612,21 @@ function parseInvestigationSourceList(value) {
   }
   return deduped;
 }
-function hash(value, length = 24) {
-  return createHash3("sha256").update(JSON.stringify(value)).digest("hex").slice(0, length);
+function hash2(value, length = 24) {
+  return createHash4("sha256").update(JSON.stringify(value)).digest("hex").slice(0, length);
 }
 function expandPath(path, env) {
   return path.replace(/^~(?=\/|$)/, env.home).replace(/\$CWD/g, env.cwd).replace(/\$HOME/g, env.home);
 }
-function safeStat(path) {
+function safeStat2(path) {
   try {
-    return statSync4(path);
+    return statSync5(path);
   } catch {
     return null;
   }
 }
 function walkFiles(root, predicate, maxFiles = 500) {
-  if (!existsSync6(root)) return [];
+  if (!existsSync7(root)) return [];
   const files = [];
   const stack = [root];
   const ignored = /* @__PURE__ */ new Set(["node_modules", ".git", ".next", "dist", "build", ".turbo"]);
@@ -6547,14 +6635,14 @@ function walkFiles(root, predicate, maxFiles = 500) {
     if (!current) continue;
     let entries;
     try {
-      entries = readdirSync4(current);
+      entries = readdirSync5(current);
     } catch {
       continue;
     }
     for (const entry of entries) {
       if (ignored.has(entry)) continue;
-      const path = join5(current, entry);
-      const stats = safeStat(path);
+      const path = join6(current, entry);
+      const stats = safeStat2(path);
       if (!stats) continue;
       if (stats.isDirectory()) {
         stack.push(path);
@@ -6606,10 +6694,10 @@ function nowWindow(timestamp, now) {
   return "older";
 }
 function makeRawEvent(input) {
-  const contentHash = hash(input.payload, 64);
+  const contentHash = hash2(input.payload, 64);
   const uri = `${input.client}:${input.sessionId}:${input.uriSuffix}`;
   return {
-    event_id: `evt_${hash([uri, contentHash], 24)}`,
+    event_id: `evt_${hash2([uri, contentHash], 24)}`,
     source_ref: {
       source_id: input.client,
       uri,
@@ -6652,7 +6740,7 @@ function parseJsonLine2(line) {
 }
 function readTextWindow(path, stats, maxBytes) {
   if (stats.size <= maxBytes) {
-    return { text: readFileSync4(path, "utf8"), truncated: false };
+    return { text: readFileSync5(path, "utf8"), truncated: false };
   }
   const bytesToRead = Math.min(stats.size, maxBytes);
   const buffer = Buffer.alloc(bytesToRead);
@@ -6796,7 +6884,7 @@ function mapClaudeRecord(record, fallbackTimestamp) {
   return out;
 }
 function readJsonlCandidate(candidate, options) {
-  const stats = safeStat(candidate.path);
+  const stats = safeStat2(candidate.path);
   if (!stats) {
     return {
       collectionMethods: [],
@@ -6810,7 +6898,7 @@ function readJsonlCandidate(candidate, options) {
   const window = readTextWindow(candidate.path, stats, options.maxBytesPerFile);
   const lines = window.text.split(/\r?\n/);
   const fallbackTimestamp = new Date(stats.mtimeMs).toISOString();
-  const sessionId = basename3(candidate.path).replace(/\.[^.]+$/, "");
+  const sessionId = basename4(candidate.path).replace(/\.[^.]+$/, "");
   const events = [];
   for (const [index, line] of lines.entries()) {
     if (!line.trim()) continue;
@@ -6873,7 +6961,7 @@ function mapGenericJsonRecord(record, fallbackTimestamp) {
   }];
 }
 function readJsonCandidate(candidate, options) {
-  const stats = safeStat(candidate.path);
+  const stats = safeStat2(candidate.path);
   if (!stats || stats.size > options.maxBytesPerFile) {
     return {
       collectionMethods: [],
@@ -6886,7 +6974,7 @@ function readJsonCandidate(candidate, options) {
   }
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync4(candidate.path, "utf8"));
+    parsed = JSON.parse(readFileSync5(candidate.path, "utf8"));
   } catch {
     return {
       collectionMethods: [],
@@ -6899,7 +6987,7 @@ function readJsonCandidate(candidate, options) {
   }
   const records = flattenPotentialMessages(parsed).slice(0, 800);
   const fallbackTimestamp = new Date(stats.mtimeMs).toISOString();
-  const sessionId = basename3(candidate.path).replace(/\.[^.]+$/, "");
+  const sessionId = basename4(candidate.path).replace(/\.[^.]+$/, "");
   const events = records.flatMap(
     (record, index) => mapGenericJsonRecord(record, fallbackTimestamp).map(
       (item, partIndex) => makeRawEvent({
@@ -6952,7 +7040,7 @@ function flattenPotentialMessages(value) {
   return out;
 }
 function readMarkdownCandidate(candidate, options) {
-  const stats = safeStat(candidate.path);
+  const stats = safeStat2(candidate.path);
   if (!stats || stats.size > options.maxBytesPerFile) {
     return {
       collectionMethods: [],
@@ -6963,8 +7051,8 @@ function readMarkdownCandidate(candidate, options) {
       searchedSessions: 0
     };
   }
-  const text2 = readFileSync4(candidate.path, "utf8");
-  const sessionId = basename3(candidate.path).replace(/\.[^.]+$/, "");
+  const text2 = readFileSync5(candidate.path, "utf8");
+  const sessionId = basename4(candidate.path).replace(/\.[^.]+$/, "");
   const timestamp = new Date(stats.mtimeMs).toISOString();
   const event = makeRawEvent({
     client: candidate.source,
@@ -6993,7 +7081,7 @@ function readMarkdownCandidate(candidate, options) {
   };
 }
 function readGitReflogCandidate(candidate, options) {
-  const stats = safeStat(candidate.path);
+  const stats = safeStat2(candidate.path);
   if (!stats || stats.size > options.maxBytesPerFile) {
     return {
       collectionMethods: [],
@@ -7004,7 +7092,7 @@ function readGitReflogCandidate(candidate, options) {
       searchedSessions: 0
     };
   }
-  const lines = readFileSync4(candidate.path, "utf8").split(/\r?\n/).filter(Boolean).slice(-250);
+  const lines = readFileSync5(candidate.path, "utf8").split(/\r?\n/).filter(Boolean).slice(-250);
   const events = [];
   const fallbackTimestamp = new Date(stats.mtimeMs).toISOString();
   for (const [index, line] of lines.entries()) {
@@ -7150,10 +7238,10 @@ function discoverCandidates(source, env, sinceMs) {
     for (const rootPattern of paths) {
       const expanded = expandPath(rootPattern, env);
       const root = expanded.includes("*") ? expanded.slice(0, expanded.indexOf("*")).replace(/\/$/, "") : expanded;
-      const exactStats = safeStat(expanded);
+      const exactStats = safeStat2(expanded);
       const found = exactStats?.isFile() ? [expanded] : walkFiles(root, predicate);
       for (const path of found) {
-        const stats = safeStat(path);
+        const stats = safeStat2(path);
         if (!stats || stats.mtimeMs < sinceMs) continue;
         candidates.push({ extractionMode, mtimeMs: stats.mtimeMs, path, source });
       }
@@ -7221,7 +7309,7 @@ function discoverOverrideCandidates(source, root, sinceMs) {
   const files = walkFiles(root, (path) => path.endsWith(".jsonl") || path.endsWith(".json"));
   const candidates = [];
   for (const path of files) {
-    const stats = safeStat(path);
+    const stats = safeStat2(path);
     if (!stats || stats.mtimeMs < sinceMs) continue;
     candidates.push({ extractionMode, mtimeMs: stats.mtimeMs, path, source });
   }
@@ -7296,7 +7384,7 @@ function extractionFromEvents(input) {
   }
   return {
     schema_version: "2.0.0.investigation",
-    extraction_id: `${input.client}:investigation:${hash([input.client, input.events.map((event) => event.event_id)], 12)}`,
+    extraction_id: `${input.client}:investigation:${hash2([input.client, input.events.map((event) => event.event_id)], 12)}`,
     source_client: workGraphSourceClient(input.client),
     source_label: clientLabel(input.client),
     collection_methods: [...new Set(input.collectionMethods)].sort(),
@@ -7389,7 +7477,7 @@ function loadWorkGraphInvestigationSourceData(options) {
 }
 
 // src/lib/self-audit.ts
-import { createHash as createHash4 } from "crypto";
+import { createHash as createHash5 } from "crypto";
 var SELF_AUDIT_SCHEMA_VERSION = "2026-04-27";
 var AUDIT_DIMENSIONS = [
   "queryability",
@@ -7556,7 +7644,7 @@ function buildSelfCritique(scores) {
   });
 }
 function hashPlanPayload(payload) {
-  return createHash4("sha256").update(JSON.stringify(payload)).digest("hex");
+  return createHash5("sha256").update(JSON.stringify(payload)).digest("hex");
 }
 function buildSelfAuditPlan(input) {
   if (input.imports.length === 0) {
@@ -7886,10 +7974,10 @@ Rollback: ${plan.recommended_follow_up.rollback}`,
 }
 
 // src/lib/work-graph.ts
-import { createHash as createHash6 } from "crypto";
+import { createHash as createHash7 } from "crypto";
 
 // src/lib/work-graph-investigation.ts
-import { createHash as createHash5 } from "crypto";
+import { createHash as createHash6 } from "crypto";
 var WORK_GRAPH_INVESTIGATION_SCHEMA_VERSION = "2.0.0";
 var WORK_GRAPH_INVESTIGATION_CLIENTS = [
   "claude_code",
@@ -8021,8 +8109,8 @@ var CAPABILITY_CEILINGS = {
     decision_lineage: "high"
   }
 };
-function hash2(value, length = 16) {
-  return createHash5("sha256").update(JSON.stringify(value)).digest("hex").slice(0, length);
+function hash3(value, length = 16) {
+  return createHash6("sha256").update(JSON.stringify(value)).digest("hex").slice(0, length);
 }
 function clamp(value, min = 0, max = 1) {
   return Math.max(min, Math.min(max, value));
@@ -8075,8 +8163,8 @@ function loopTopicKey(loop) {
   for (const [pattern, topic] of topicRules) {
     if (pattern.test(text2)) return topic;
   }
-  if (!intent) return `unclassified:${hash2(loop.loop_id, 10)}`;
-  return `topic:${hash2(intent.toLowerCase(), 10)}`;
+  if (!intent) return `unclassified:${hash3(loop.loop_id, 10)}`;
+  return `topic:${hash3(intent.toLowerCase(), 10)}`;
 }
 function bestFamilyCentroid(group) {
   const candidates = group.map((loop) => cleanLoopIntent(loop.origin.intent, "")).filter(Boolean).map((intent) => {
@@ -8140,7 +8228,7 @@ function windowFor(timestamp, now) {
 function rawEventFromFinding(finding, index, generatedAt) {
   const sourceClient = normalizeClient(finding.source_client);
   const timestamp = typeof finding.metadata.occurred_at === "string" ? finding.metadata.occurred_at : generatedAt;
-  const eventId = `evt_${hash2([finding.evidence_ref, finding.title, index], 24)}`;
+  const eventId = `evt_${hash3([finding.evidence_ref, finding.title, index], 24)}`;
   const payload = {
     title: finding.title,
     summary: finding.summary,
@@ -8172,7 +8260,7 @@ function rawEventFromFinding(finding, index, generatedAt) {
     payload,
     raw_byte_offset: null,
     raw_row_id: null,
-    content_hash: hash2(payload, 64),
+    content_hash: hash3(payload, 64),
     redaction_applied: true
   };
 }
@@ -8184,7 +8272,7 @@ function rawEventFromSourceEvent(event, index, generatedAt) {
     text_summary: event.text.slice(0, 420)
   };
   return {
-    event_id: `evt_${hash2([event.evidence_ref, index], 24)}`,
+    event_id: `evt_${hash3([event.evidence_ref, index], 24)}`,
     source_ref: {
       source_id: sourceClient,
       uri: event.evidence_ref,
@@ -8202,7 +8290,7 @@ function rawEventFromSourceEvent(event, index, generatedAt) {
     payload,
     raw_byte_offset: null,
     raw_row_id: null,
-    content_hash: hash2(payload, 64),
+    content_hash: hash3(payload, 64),
     redaction_applied: true
   };
 }
@@ -8333,7 +8421,7 @@ function buildWorkLoops(input) {
       trail.confidence || matchedFindings.reduce((total, finding) => total + finding.confidence, 0) / Math.max(1, matchedFindings.length)
     );
     return {
-      loop_id: `loop_${hash2([trail.id, index], 18)}`,
+      loop_id: `loop_${hash3([trail.id, index], 18)}`,
       cites: eventIds,
       origin: {
         event_id: eventIds[0] ?? `evt_missing_${index}`,
@@ -8419,7 +8507,7 @@ function buildLoopFamilies(loops, events, impact) {
         (loop) => loop.cites.map((cite) => events.find((event) => event.event_id === cite)?.source_id).filter(Boolean)
       )
     );
-    const familyId = `family_${hash2(key, 16)}`;
+    const familyId = `family_${hash3(key, 16)}`;
     const timestamps = group.map((loop) => Date.parse(loop.origin.timestamp)).filter(Number.isFinite);
     const spanDays = timestamps.length > 1 ? Math.max(1, Math.ceil((Math.max(...timestamps) - Math.min(...timestamps)) / 864e5)) : 0;
     const publicLoopCount = group.filter((loop) => loop.public_surface).length;
@@ -8772,7 +8860,7 @@ function counterfactualForLoop(loop, family) {
     orgx_outcome: repair.expected_outcome,
     resulting_entity: {
       kind: entityKind,
-      inferred_id: `orgx_${entityKind}_${hash2(loop.loop_id, 12)}`,
+      inferred_id: `orgx_${entityKind}_${hash3(loop.loop_id, 12)}`,
       would_link_to: loop.cites
     },
     realism_score: Number(realism.toFixed(2)),
@@ -8983,7 +9071,7 @@ function buildMirror(input) {
   };
 }
 function buildWorkGraphInvestigation(input) {
-  const auditId = `wgi_${hash2([input.fingerprint, input.generatedAt], 24)}`;
+  const auditId = `wgi_${hash3([input.fingerprint, input.generatedAt], 24)}`;
   const rawEvents = buildRawEvents(input);
   const corpus = buildCorpusManifest({
     auditId,
@@ -9124,7 +9212,7 @@ function clampScore2(value) {
   return Math.max(0, Math.min(100, Math.round(value)));
 }
 function hashJson(value) {
-  return createHash6("sha256").update(JSON.stringify(value)).digest("hex");
+  return createHash7("sha256").update(JSON.stringify(value)).digest("hex");
 }
 function normalizeFingerprintText(value) {
   return value.toLowerCase().replace(/https?:\/\/\S+/g, "url").replace(/[0-9a-f]{12,}/g, "hash").replace(/\b[0-9a-f]{8}-[0-9a-f-]{27,}\b/g, "uuid").replace(/\s+/g, " ").trim().slice(0, 600);
@@ -12215,14 +12303,14 @@ function renderWorkGraphMarkdown(report, options = {}) {
 }
 
 // src/lib/work-graph-publish.ts
-import { createHash as createHash7, randomUUID as randomUUID2 } from "crypto";
+import { createHash as createHash8, randomUUID as randomUUID2 } from "crypto";
 import { gzipSync } from "zlib";
 var WORK_GRAPH_REPORT_GZIP_THRESHOLD_BYTES = 4e6;
 var WORK_GRAPH_REPORT_CHUNK_UPLOAD_THRESHOLD_BYTES = 5e5;
 var WORK_GRAPH_REPORT_CHUNK_CHARS = 3e4;
 var WORK_GRAPH_REPORT_CHUNK_UPLOAD_TIMEOUT_MS = 3e5;
 function hashText(value) {
-  return createHash7("sha256").update(value).digest("hex");
+  return createHash8("sha256").update(value).digest("hex");
 }
 function buildWorkGraphReportPostPayload(report, options = {}) {
   return {
@@ -12429,8 +12517,8 @@ async function publishWorkGraphEvents(fingerprint, patch, options = {}) {
 }
 
 // src/lib/work-graph-hook-events.ts
-import { createHash as createHash8 } from "crypto";
-import { existsSync as existsSync7, readFileSync as readFileSync5 } from "fs";
+import { createHash as createHash9 } from "crypto";
+import { existsSync as existsSync8, readFileSync as readFileSync6 } from "fs";
 var SOURCE_CLIENTS = [
   "codex",
   "claude",
@@ -12464,7 +12552,7 @@ function asStringArray(value) {
   return value.filter((item) => typeof item === "string" && item.trim().length > 0);
 }
 function stableHash(value) {
-  return createHash8("sha256").update(value).digest("hex").slice(0, 20);
+  return createHash9("sha256").update(value).digest("hex").slice(0, 20);
 }
 function normalizeSourceClient2(value) {
   const raw = asString2(value)?.toLowerCase();
@@ -12531,8 +12619,8 @@ function readHookRecord(line) {
   }
 }
 function readRuntimeHookOutbox(path, limit = 200) {
-  if (!existsSync7(path)) return { path, records: [], skipped: 0 };
-  const lines = readFileSync5(path, "utf8").split(/\r?\n/).filter((line) => line.trim().length > 0);
+  if (!existsSync8(path)) return { path, records: [], skipped: 0 };
+  const lines = readFileSync6(path, "utf8").split(/\r?\n/).filter((line) => line.trim().length > 0);
   const selected = lines.slice(Math.max(0, lines.length - Math.max(1, limit)));
   const records = [];
   let skipped = Math.max(0, lines.length - selected.length);
@@ -12668,20 +12756,20 @@ function buildWorkGraphHookReplayPatch(readResult) {
 }
 
 // src/lib/runtime-hooks.ts
-import { copyFileSync, existsSync as existsSync8, mkdirSync as mkdirSync3 } from "fs";
+import { copyFileSync, existsSync as existsSync9, mkdirSync as mkdirSync3 } from "fs";
 import { homedir as homedir3 } from "os";
-import { dirname as dirname4, join as join6 } from "path";
+import { dirname as dirname4, join as join7 } from "path";
 var HOOK_MARKER = "orgx-session-hook.mjs";
 var HOOK_EVENTS = ["SessionStart", "UserPromptSubmit", "PreToolUse", "PostToolUse", "PermissionRequest", "Stop"];
 var CLAUDE_HOOK_EVENTS = ["SessionStart", "UserPromptSubmit", "PreToolUse", "PostToolUse", "SubagentStop", "Stop", "SessionEnd"];
 function defaultPaths(options = {}) {
-  const hookDir = join6(ORGX_WIZARD_CONFIG_HOME, "hooks");
+  const hookDir = join7(ORGX_WIZARD_CONFIG_HOME, "hooks");
   return {
-    claudeSettingsPath: options.claudeSettingsPath ?? join6(CLAUDE_DIR, "settings.json"),
-    codexConfigPath: options.codexConfigPath ?? CODEX_CONFIG_PATH ?? join6(CODEX_DIR, "config.toml"),
-    codexHooksPath: options.codexHooksPath ?? join6(CODEX_DIR, "hooks.json"),
-    hookScriptPath: options.hookScriptPath ?? join6(hookDir, HOOK_MARKER),
-    outboxPath: options.outboxPath ?? join6(hookDir, "events.jsonl")
+    claudeSettingsPath: options.claudeSettingsPath ?? join7(CLAUDE_DIR, "settings.json"),
+    codexConfigPath: options.codexConfigPath ?? CODEX_CONFIG_PATH ?? join7(CODEX_DIR, "config.toml"),
+    codexHooksPath: options.codexHooksPath ?? join7(CODEX_DIR, "hooks.json"),
+    hookScriptPath: options.hookScriptPath ?? join7(hookDir, HOOK_MARKER),
+    outboxPath: options.outboxPath ?? join7(hookDir, "events.jsonl")
   };
 }
 function countJsonlLines(path) {
@@ -12694,7 +12782,7 @@ function backupPath(path, now) {
   return `${path}.bak.${timestamp}`;
 }
 function backupExisting(path, now) {
-  if (!existsSync8(path)) return null;
+  if (!existsSync9(path)) return null;
   const backup = backupPath(path, now);
   copyFileSync(path, backup);
   return backup;
@@ -12892,7 +12980,7 @@ function inspectRuntimeHooks(options = {}) {
     installed: {
       claudeCode: hasOrgxHook(claudeSettingsRaw),
       codex: hasOrgxHook(codexHooksRaw),
-      hookScript: existsSync8(paths.hookScriptPath)
+      hookScript: existsSync9(paths.hookScriptPath)
     },
     codex: {
       configExists: Boolean(codexConfigRaw),
@@ -13154,10 +13242,10 @@ async function runHookReplayCommand(options) {
 }
 function readAuditInput(options, interactive) {
   if (options.input?.trim()) {
-    return readFileSync7(resolve2(options.input.trim()), "utf8");
+    return readFileSync8(resolve2(options.input.trim()), "utf8");
   }
   if (!process.stdin.isTTY) {
-    return readFileSync7(0, "utf8");
+    return readFileSync8(0, "utf8");
   }
   if (!interactive) {
     throw new Error("Audit input is required. Pass --input <file> or pipe text into wizard audit.");
@@ -13190,7 +13278,7 @@ function collectPathOption(value, previous = []) {
 }
 function parseClientExtractionFile(path) {
   const resolvedPath = resolve2(path);
-  const parsed = JSON.parse(readFileSync7(resolvedPath, "utf8"));
+  const parsed = JSON.parse(readFileSync8(resolvedPath, "utf8"));
   if (!isRecord(parsed)) {
     throw new Error(`AI-client extraction must be a JSON object: ${resolvedPath}`);
   }
@@ -13675,6 +13763,40 @@ function printSkillExtensions(extensions) {
     );
   }
 }
+function printLocalSkillCandidates(candidates) {
+  if (candidates.length === 0) {
+    console.log(`  ${ICON.skip}  ${pc3.dim("no local skill files found")}`);
+    return;
+  }
+  candidates.forEach((candidate, index) => {
+    const domains = candidate.agentDomains.join(", ");
+    console.log(
+      `  ${ICON.ok}  ${pc3.bold(String(index + 1).padStart(2, " "))} ${pc3.bold(candidate.title)} ${pc3.dim(candidate.id)}`
+    );
+    console.log(`       ${pc3.dim(`${candidate.source} \xB7 ${domains} \xB7 ${candidate.reason}`)}`);
+    console.log(`       ${pc3.dim(candidate.path)}`);
+    if (candidate.snippet) {
+      console.log(`       ${pc3.dim(candidate.snippet)}`);
+    }
+  });
+}
+function writeLocalSkillSelection(input) {
+  const scope = input.scope ?? "user";
+  const nextContent = buildLocalSkillExtensionContent(input.candidates, input.context);
+  const existing = listSkillExtensions().find(
+    (extension) => extension.skillId === "orgx" && extension.scope === scope
+  );
+  const content = existing?.content.trim() ? `${existing.content.trimEnd()}
+
+${nextContent}` : nextContent;
+  return addSkillExtension({
+    content,
+    overwrite: true,
+    scope,
+    skillId: "orgx",
+    title: "Local skill preferences"
+  });
+}
 function printSkillExtensionWrite(result) {
   const action = result.created ? "created" : result.changed ? "updated" : "unchanged";
   const color = result.created || result.changed ? pc3.green : pc3.dim;
@@ -13740,6 +13862,8 @@ function printSetupScopeNote() {
 }
 function printFirstValueHandoff(input) {
   const cmd = getCmd();
+  const fallbackPrompt = `Use OrgX to continue "${input.initiative.initiative.title}" in ${input.workspace.name}. Show the next action, then start with the onboarding task.`;
+  const handoffPrompt = buildProfileHandoffPrompt(input.profile, fallbackPrompt, input.context);
   console.log("");
   console.log(pc3.bold("first OrgX handoff"));
   console.log(
@@ -13748,9 +13872,13 @@ function printFirstValueHandoff(input) {
   console.log(`  live: ${input.initiative.liveUrl}`);
   console.log(
     `  ${pc3.dim("ask your AI tool:")} ${pc3.cyan(
-      `Use OrgX to continue "${input.initiative.initiative.title}" in ${input.workspace.name}. Show the next action, then start with the onboarding task.`
+      handoffPrompt
     )}`
   );
+  if (input.profile) {
+    console.log(`  ${pc3.dim("local proof:")} ${pc3.cyan(input.profile.localProofCommand)}`);
+    console.log(`  ${pc3.dim("skills:")} ${pc3.cyan(input.profile.skillDiscoveryCommand)}`);
+  }
   console.log(`  ${pc3.dim("later:")} ${pc3.cyan(`${cmd} doctor`)} ${pc3.dim("checks tool wiring")}`);
 }
 function firstValueRecordToResult(record) {
@@ -13775,20 +13903,6 @@ function printFounderPresetResult(result) {
     console.log("");
     printWorkspaceSetupResult(result.workspaceSetup);
   }
-  if (result.demoInitiative) {
-    console.log("");
-    console.log(pc3.bold("demo initiative"));
-    console.log(
-      `  ${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) {
   return value;
@@ -14213,10 +14327,9 @@ async function maybeConfigureOptionalWorkspaceAddOns(input) {
   }
   const existingState = readWizardState();
   const providedInitiativeId = input.initiativeId?.trim();
-  const storedDemoInitiative = existingState?.demoInitiative?.workspaceId === input.workspace.id ? existingState.demoInitiative : void 0;
   const storedFirstValueInitiative = existingState?.firstValueInitiative?.workspaceId === input.workspace.id ? existingState.firstValueInitiative : void 0;
-  let effectiveInitiativeId = providedInitiativeId || storedDemoInitiative?.id || storedFirstValueInitiative?.id;
-  let firstValueInitiative = providedInitiativeId || storedDemoInitiative ? null : firstValueRecordToResult(storedFirstValueInitiative);
+  let effectiveInitiativeId = providedInitiativeId || storedFirstValueInitiative?.id;
+  let firstValueInitiative = providedInitiativeId ? null : firstValueRecordToResult(storedFirstValueInitiative);
   const firstInitiativeSkipped = hasSetupPromptSkip(
     input.workspace.id,
     "first_initiative"
@@ -14240,7 +14353,7 @@ async function maybeConfigureOptionalWorkspaceAddOns(input) {
     }
     if (firstInitiativeChoice === "yes") {
       const title = await textPrompt({
-        initialValue: FIRST_VALUE_INITIATIVE_TITLE,
+        initialValue: input.profile?.firstInitiativeTitle ?? FIRST_VALUE_INITIATIVE_TITLE,
         message: "What should OrgX help you move forward first?",
         validate: (value) => {
           if (!value || value.trim().length === 0) {
@@ -14257,6 +14370,7 @@ async function maybeConfigureOptionalWorkspaceAddOns(input) {
       spinner.start();
       try {
         firstValueInitiative = await ensureFirstValueInitiative(input.workspace, {
+          ...input.context || input.profile ? { summary: input.profile ? buildProfileSummary(input.profile, input.context) : input.context } : {},
           title: String(title)
         });
         spinner.succeed(
@@ -14347,7 +14461,9 @@ async function maybeConfigureOptionalWorkspaceAddOns(input) {
   }
   if (firstValueInitiative) {
     printFirstValueHandoff({
+      ...input.context ? { context: input.context } : {},
       initiative: firstValueInitiative,
+      ...input.profile !== void 0 ? { profile: input.profile } : {},
       workspace: input.workspace
     });
   }
@@ -14420,6 +14536,64 @@ async function maybeConfigureOptionalWorkspaceAddOns(input) {
       });
     }
   }
+  const localSkillDiscoverySkipped = hasSetupPromptSkip(
+    input.workspace.id,
+    "local_skill_discovery"
+  );
+  if (!localSkillDiscoverySkipped) {
+    const context = input.context?.trim();
+    const candidates = discoverLocalSkills({
+      ...context ? { context } : {},
+      limit: 8
+    });
+    if (candidates.length > 0) {
+      const selectedSkillIds = await multiselectPrompt({
+        message: "Bring existing local skills into your OrgX agents?",
+        options: [
+          ...candidates.map((candidate, index) => ({
+            value: candidate.id,
+            label: `${index + 1}. ${candidate.title}`,
+            hint: `${candidate.source} \xB7 ${candidate.agentDomains.join(", ")} \xB7 ${candidate.reason}`
+          })),
+          {
+            value: "__skip__",
+            label: "Skip local skill import",
+            hint: "You can run `orgx-wizard skills discover-local` later."
+          }
+        ],
+        required: false
+      });
+      if (clack.isCancel(selectedSkillIds)) {
+        clack.cancel("Setup cancelled.");
+        return "cancelled";
+      }
+      const selected = candidates.filter((candidate) => selectedSkillIds.includes(candidate.id));
+      if (selectedSkillIds.includes("__skip__") || selected.length === 0) {
+        recordSetupPromptSkip({
+          promptKey: "local_skill_discovery",
+          workspaceId: input.workspace.id,
+          workspaceName: input.workspace.name
+        });
+        console.log(`  ${ICON.skip}  ${pc3.dim("local skills skipped")}`);
+      } else {
+        const result = writeLocalSkillSelection({
+          candidates: selected,
+          ...context ? { context } : {}
+        });
+        printSkillExtensionWrite(result);
+        console.log(
+          `  ${ICON.skip}  ${pc3.dim(`Run ${getCmd()} skills sync to apply selected local preferences to configured tools.`)}`
+        );
+        await safeTrackWizardTelemetry("local_skills_configured", {
+          candidate_count: candidates.length,
+          command: input.telemetry?.command ?? "setup",
+          selected_count: selected.length,
+          ...input.telemetry?.preset ? { preset: input.telemetry.preset } : {},
+          profile: input.profile?.id ?? "none"
+        });
+      }
+    }
+  }
   return "configured";
 }
 async function promptOptionalCompanionPluginTargets(input) {
@@ -14509,7 +14683,7 @@ function printAuthStatus(status) {
   }
 }
 function printDoctorReport(report, assessment) {
-  const verification = summarizeSetupVerification(assessment);
+  const verification = summarizeSetupVerification(assessment, report);
   console.log(pc3.dim("  surfaces"));
   printSurfaceTable(report.surfaces);
   console.log("");
@@ -14557,6 +14731,9 @@ function printDoctorReport(report, assessment) {
     } else {
       console.log(`  ${pc3.dim("\u2192")}  ${pc3.dim(`OrgX is active across ${configuredCount} editor${configuredCount !== 1 ? "s" : ""}`)}`);
     }
+  } else if (verification.transientTimeouts) {
+    console.log(`  ${ICON.warn}  ${pc3.yellow(getSetupVerificationHeadline(verification))}`);
+    console.log(`  ${pc3.dim("\u2192")}  ${pc3.cyan(`${getCmd()} doctor`)}  ${pc3.dim("re-runs the health checks")}`);
   } else {
     const headlineText = getSetupVerificationHeadline(verification);
     const headline = verification.status === "error" ? `${ICON.err}  ${pc3.red(headlineText)}` : `${ICON.warn}  ${pc3.yellow(headlineText)}`;
@@ -14573,20 +14750,26 @@ function printDoctorReport(report, assessment) {
 async function main() {
   const program = new Command();
   program.name("orgx-wizard").description("Add OrgX MCP configs, skills/rules, and companion plugins to your local AI tools.").showHelpAfterError();
-  const pkgVersion = true ? "0.1.45" : void 0;
+  const pkgVersion = true ? "0.1.47" : void 0;
   program.version(pkgVersion ?? "unknown", "-V, --version");
   program.hook("preAction", (_thisCommand, actionCommand) => {
     if (Boolean(actionCommand.optsWithGlobals().json)) return;
     console.log(renderBanner(pkgVersion));
   });
-  program.command("setup").description("Add OrgX MCP configs, skills/rules, and companion plugins to detected tools.").option("--preset <name>", "run a setup bundle (currently: founder)").option("--workspace", "choose or change the default workspace during setup").option("--daily-brief", "configure Daily Brief even if setup already handled it").option("--skip-daily-brief", "skip Daily Brief prompts and remember the skip").action(async (options) => {
+  program.command("setup").description("Add OrgX MCP configs, skills/rules, and companion plugins to detected tools.").option("--preset <name>", "run a setup bundle (currently: founder)").option("--profile <name>", `tailor setup for a workflow profile (${supportedSetupProfileIds().join(", ")})`).option("--context <text>", "extra workflow context to include in the first initiative and handoff").option("--workspace", "choose or change the default workspace during setup").option("--daily-brief", "configure Daily Brief even if setup already handled it").option("--skip-daily-brief", "skip Daily Brief prompts and remember the skip").action(async (options) => {
     const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY);
     if (options.dailyBrief && options.skipDailyBrief) {
       throw new Error("Use either --daily-brief or --skip-daily-brief, not both.");
     }
+    const setupProfile = resolveSetupProfile(options.profile);
+    if (options.profile && !setupProfile) {
+      throw new Error(`Unknown setup profile '${options.profile}'. Supported profiles: ${supportedSetupProfileIds().join(", ")}.`);
+    }
+    const setupContext = options.context?.trim() || void 0;
     await safeTrackWizardTelemetry("wizard_started", {
       command: "setup",
       interactive,
+      profile: setupProfile?.id ?? "none",
       preset: options.preset ?? "standard"
     });
     printSetupScopeNote();
@@ -14646,20 +14829,12 @@ async function main() {
           })
         );
       }
-      if (presetResult.demoInitiative) {
-        await safeTrackWizardTelemetry(
-          "founder_demo_ready",
-          buildFounderDemoTelemetryProperties(presetResult.demoInitiative, {
-            command: "setup",
-            preset: "founder"
-          })
-        );
-      }
       const addOnResult = await maybeConfigureOptionalWorkspaceAddOns({
+        ...setupContext ? { context: setupContext } : {},
         interactive,
+        profile: setupProfile,
         telemetry: { command: "setup", preset: "founder" },
-        workspace: presetResult.workspace,
-        ...presetResult.demoInitiative ? { initiativeId: presetResult.demoInitiative.initiative.id } : {}
+        workspace: presetResult.workspace
       });
       if (addOnResult === "cancelled") {
         return;
@@ -14671,7 +14846,7 @@ async function main() {
       console.log("");
       const doctor2 = await runDoctor();
       const assessment2 = assessDoctorReport(doctor2);
-      const verification2 = summarizeSetupVerification(assessment2);
+      const verification2 = summarizeSetupVerification(assessment2, doctor2);
       await safeTrackWizardTelemetry(
         "setup_verified",
         buildDoctorTelemetryProperties(doctor2, assessment2, verification2, {
@@ -14698,6 +14873,7 @@ async function main() {
     });
     const wasAlreadyPaired = await resolveOrgxAuth() !== null;
     let resolvedAuth = await resolveOrgxAuth();
+    let cachedWorkspaceCheck;
     if (!resolvedAuth) {
       console.log("");
       if (interactive) {
@@ -14781,6 +14957,20 @@ async function main() {
         })
       );
       const resolvedWorkspace = workspaceSetup.workspace ?? await getCurrentWorkspace().catch(() => null);
+      if (resolvedWorkspace && resolvedAuth) {
+        cachedWorkspaceCheck = {
+          configured: true,
+          ok: true,
+          skipped: false,
+          source: resolvedAuth.source,
+          baseUrl: resolvedAuth.baseUrl,
+          workspace: resolvedWorkspace,
+          details: [
+            `workspace id: ${resolvedWorkspace.id}`,
+            ...resolvedWorkspace.isDefault ? ["workspace is marked as default"] : []
+          ]
+        };
+      }
       if (resolvedWorkspace) {
         persistContinuityDefaults({ workspace: resolvedWorkspace });
       }
@@ -14817,7 +15007,9 @@ async function main() {
         return;
       }
       const addOnResult = await maybeConfigureOptionalWorkspaceAddOns({
+        ...setupContext ? { context: setupContext } : {},
         interactive,
+        profile: setupProfile,
         telemetry: { command: "setup", preset: "standard" },
         workspace: resolvedWorkspace
       });
@@ -14833,9 +15025,11 @@ async function main() {
         return;
       }
     }
-    const doctor = await runDoctor();
+    const doctor = await runDoctor(
+      cachedWorkspaceCheck ? { cachedWorkspace: cachedWorkspaceCheck } : {}
+    );
     const assessment = assessDoctorReport(doctor);
-    const verification = summarizeSetupVerification(assessment);
+    const verification = summarizeSetupVerification(assessment, doctor);
     await safeTrackWizardTelemetry(
       "setup_verified",
       buildDoctorTelemetryProperties(doctor, assessment, verification, {
@@ -15352,7 +15546,7 @@ async function main() {
     const report = await runDoctor();
     spinner.stop();
     const assessment = assessDoctorReport(report);
-    const verification = summarizeSetupVerification(assessment);
+    const verification = summarizeSetupVerification(assessment, report);
     await safeTrackWizardTelemetry(
       "doctor_ran",
       buildDoctorTelemetryProperties(report, assessment, verification, {
@@ -15421,6 +15615,48 @@ async function main() {
       }
     }
   });
+  skills.command("discover-local").description("Inventory local skill files and optionally fold selected ones into the OrgX base skill extension.").option("--from <sources>", "local sources to scan: opencode, claude, codex, agents, workspace, or all", "all").option("--context <text>", "workflow context used to rank and annotate discovered skills").option("--limit <count>", "max candidates to show", "12").option("--apply <selection>", "comma-separated candidate numbers or ids to opt into the OrgX base skill extension").option("--scope <scope>", "extension scope: user, workspace, or project", "user").option("--json", "emit a JSON summary").action(async (options) => {
+    const sources = parseLocalSkillSources(options.from);
+    const limit = parsePositiveInteger(options.limit, 12, "--limit");
+    const candidates = discoverLocalSkills({
+      ...options.context?.trim() ? { context: options.context.trim() } : {},
+      limit,
+      sources
+    });
+    let extensionWrite = null;
+    if (options.apply?.trim()) {
+      const selected = selectLocalSkillCandidates(candidates, options.apply);
+      extensionWrite = writeLocalSkillSelection({
+        candidates: selected,
+        ...options.context?.trim() ? { context: options.context.trim() } : {},
+        scope: options.scope ?? "user"
+      });
+    }
+    if (options.json) {
+      console.log(JSON.stringify({
+        applied: extensionWrite ? {
+          changed: extensionWrite.changed,
+          created: extensionWrite.created,
+          path: extensionWrite.path
+        } : null,
+        candidates
+      }, null, 2));
+      return;
+    }
+    printLocalSkillCandidates(candidates);
+    if (extensionWrite) {
+      console.log("");
+      printSkillExtensionWrite(extensionWrite);
+      console.log(
+        `  ${ICON.skip}  ${pc3.dim(`Run ${getCmd()} skills sync to apply selected local preferences to configured tools.`)}`
+      );
+    } else if (candidates.length > 0) {
+      console.log("");
+      console.log(
+        `  ${ICON.skip}  ${pc3.dim(`Opt in with ${getCmd()} skills discover-local --apply 1,2, then run ${getCmd()} skills sync.`)}`
+      );
+    }
+  });
   const skillExtensions = skills.command("extensions").description("Create, edit, and sync user extensions appended after OrgX core skills.");
   skillExtensions.command("list").description("List local OrgX skill extensions.").action(() => {
     printSkillExtensions(listSkillExtensions());