@useorgx/wizard 0.1.17 → 0.1.20

package/dist/cli.js

@@ -1300,6 +1300,39 @@ function parseSkillFiles(value) {
     updatedAt: record.updatedAt.trim()
   };
 }
+function parsePeopleFirstCaptureEntry(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return void 0;
+  }
+  const record = value;
+  if (!isNonEmptyString2(record.workspaceId) || !isNonEmptyString2(record.completedAt)) {
+    return void 0;
+  }
+  return {
+    workspaceId: record.workspaceId.trim(),
+    completedAt: record.completedAt.trim(),
+    ...isNonEmptyString2(record.personId) ? { personId: record.personId.trim() } : {},
+    ...isNonEmptyString2(record.templatePersona) ? { templatePersona: record.templatePersona.trim() } : {},
+    ...record.stagedLocally === true ? { stagedLocally: true } : {}
+  };
+}
+function parsePeopleFirstCapture(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return void 0;
+  }
+  const record = value;
+  if (!isNonEmptyString2(record.updatedAt) || !Array.isArray(record.entries)) {
+    return void 0;
+  }
+  const entries = record.entries.map((entry) => parsePeopleFirstCaptureEntry(entry)).filter(
+    (entry) => Boolean(entry)
+  );
+  if (entries.length === 0) return void 0;
+  return {
+    updatedAt: record.updatedAt.trim(),
+    entries
+  };
+}
 function createWizardState(now = (/* @__PURE__ */ new Date()).toISOString()) {
   return {
     installationId: `wizard-${randomUUID()}`,
@@ -1314,6 +1347,7 @@ function sanitizeWizardStateRecord(record) {
   const firstValueInitiative = parseFirstValueInitiative(record.firstValueInitiative);
   const onboardingTask = parseOnboardingTask(record.onboardingTask);
   const skillFiles = parseSkillFiles(record.skillFiles);
+  const peopleFirstCapture = parsePeopleFirstCapture(record.peopleFirstCapture);
   return {
     installationId: record.installationId.trim(),
     createdAt: record.createdAt.trim(),
@@ -1323,7 +1357,8 @@ function sanitizeWizardStateRecord(record) {
     ...demoInitiative ? { demoInitiative } : {},
     ...firstValueInitiative ? { firstValueInitiative } : {},
     ...onboardingTask ? { onboardingTask } : {},
-    ...skillFiles ? { skillFiles } : {}
+    ...skillFiles ? { skillFiles } : {},
+    ...peopleFirstCapture ? { peopleFirstCapture } : {}
   };
 }
 function readWizardState(statePath = ORGX_WIZARD_STATE_PATH) {
@@ -1350,8 +1385,32 @@ function readWizardState(statePath = ORGX_WIZARD_STATE_PATH) {
   if (onboardingTask !== void 0) state.onboardingTask = onboardingTask;
   const skillFiles = parseSkillFiles(parsed.skillFiles);
   if (skillFiles !== void 0) state.skillFiles = skillFiles;
+  const peopleFirstCapture = parsePeopleFirstCapture(parsed.peopleFirstCapture);
+  if (peopleFirstCapture !== void 0) state.peopleFirstCapture = peopleFirstCapture;
   return state;
 }
+function hasPeopleFirstCaptureCompleted(workspaceId, statePath = ORGX_WIZARD_STATE_PATH) {
+  const state = readWizardState(statePath);
+  if (!state?.peopleFirstCapture) return false;
+  return state.peopleFirstCapture.entries.some(
+    (entry) => entry.workspaceId === workspaceId
+  );
+}
+function recordPeopleFirstCaptureCompletion(entry, statePath = ORGX_WIZARD_STATE_PATH) {
+  return updateWizardState((current) => {
+    const existingEntries = current.peopleFirstCapture?.entries ?? [];
+    const withoutExisting = existingEntries.filter(
+      (e) => e.workspaceId !== entry.workspaceId
+    );
+    return {
+      ...current,
+      peopleFirstCapture: {
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        entries: [...withoutExisting, entry]
+      }
+    };
+  }, statePath);
+}
 function writeWizardState(value, statePath = ORGX_WIZARD_STATE_PATH) {
   const record = sanitizeWizardStateRecord(value);
   writeJsonFile(statePath, record, { mode: 384 });
@@ -4916,6 +4975,7 @@ function countPluginReportChanges(report) {
 // 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;
@@ -5025,24 +5085,35 @@ async function runWorkspaceSetup(client, prompts, options) {
   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: "No OrgX workspaces were found. What should setup do next?",
+      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: "Create one now and set it as the default for this machine."
+          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 creating a workspace."
+          hint: "Finish surface setup without touching workspaces."
         }
       ],
-      initialValue: CREATE_WORKSPACE_VALUE
+      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.",
@@ -5525,6 +5596,536 @@ async function fetchOnboardingState(auth) {
   }
 }
 
+// src/lib/people-first-capture.ts
+var RELATIONSHIP_STAGE_OPTIONS = [
+  { value: "stranger", label: "Stranger", hint: "no prior contact yet" },
+  { value: "prospect", label: "Prospect", hint: "outreach planned or in flight (default)" },
+  { value: "conversation", label: "Conversation", hint: "active 2-way dialogue" },
+  { value: "design_partner", label: "Design partner", hint: "paid / equity track underway" },
+  { value: "paused", label: "Paused", hint: "intentional pause, not wrong fit" },
+  { value: "churned", label: "Churned", hint: "ended; history preserved" },
+  { value: "alumni", label: "Alumni", hint: "closed engagement, may return" }
+];
+var TRUST_TIER_OPTIONS = [
+  { value: "cold", label: "Cold / unknown", hint: "new or barely-met" },
+  { value: "warm", label: "Warm", hint: "know each other, some trust built" },
+  { value: "close", label: "Close", hint: "deep trust \u2014 inner-circle candidate" }
+];
+async function fetchPeopleFirstOnboardingState(auth) {
+  try {
+    const res = await fetch(
+      buildOrgxApiUrl("/v1/people/onboarding", auth.baseUrl),
+      {
+        method: "GET",
+        headers: { Authorization: `Bearer ${auth.apiKey}` },
+        signal: AbortSignal.timeout(5e3)
+      }
+    );
+    if (!res.ok) return null;
+    const body = await res.json().catch(() => null);
+    if (!body || !Array.isArray(body.workspaces)) return null;
+    return body;
+  } catch {
+    return null;
+  }
+}
+function parseContactChannels(raw) {
+  const channels = [];
+  const parts = raw.split(/[,\n]+/).map((part) => part.trim()).filter(Boolean);
+  for (const part of parts) {
+    if (/^https?:\/\/(?:www\.)?linkedin\.com\//i.test(part) || part.toLowerCase().startsWith("linkedin.com/")) {
+      channels.push({ kind: "linkedin", value: part });
+    } else if (/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(part)) {
+      channels.push({ kind: "email", value: part });
+    } else if (/^\+?[\d][\d\s()\-.]{5,}$/.test(part)) {
+      channels.push({ kind: "phone", value: part.replace(/\s+/g, "") });
+    } else {
+      channels.push({ kind: "linkedin", value: part });
+    }
+  }
+  return channels;
+}
+async function postJson(auth, path, body) {
+  try {
+    const res = await fetch(buildOrgxApiUrl(path, auth.baseUrl), {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${auth.apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(1e4)
+    });
+    const text2 = await res.text().catch(() => "");
+    let parsed = null;
+    if (text2) {
+      try {
+        parsed = JSON.parse(text2);
+      } catch {
+        parsed = text2;
+      }
+    }
+    if (!res.ok) {
+      const detail = parsed && typeof parsed === "object" && parsed && "error" in parsed ? String(parsed.error) : `HTTP ${res.status}`;
+      return { ok: false, error: detail };
+    }
+    return { ok: true, status: res.status, body: parsed };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { ok: false, error: message };
+  }
+}
+function extractId(body) {
+  if (body && typeof body === "object") {
+    const candidate = body.id ?? body.data;
+    if (typeof candidate === "string") return candidate;
+    if (candidate && typeof candidate === "object") {
+      const innerId = candidate.id;
+      if (typeof innerId === "string") return innerId;
+    }
+  }
+  return null;
+}
+var BACKEND_UNREACHABLE_HINT = "Could not sync with OrgX backend \u2014 check your network / run `orgx-wizard status`.";
+async function runPeopleFirstCapture(options) {
+  if (!options.interactive) {
+    return {
+      status: "skipped_non_interactive",
+      message: "People-first capture skipped \u2014 not attached to a TTY."
+    };
+  }
+  if (!options.workspace) {
+    return {
+      status: "skipped_no_workspace",
+      message: "People-first capture skipped \u2014 no workspace resolved."
+    };
+  }
+  if (options.alreadyCompleted) {
+    return {
+      status: "skipped_already_completed",
+      message: "People-first capture already completed for this workspace."
+    };
+  }
+  const auth = await resolveOrgxAuth();
+  if (!auth) {
+    return {
+      status: "failed",
+      message: "People-first capture needs OrgX auth.",
+      error: "no_auth"
+    };
+  }
+  const state = await fetchPeopleFirstOnboardingState(auth);
+  if (state) {
+    const row = state.workspaces.find((w) => w.id === options.workspace.id);
+    if (row?.peopleFirstCaptureCompletedAt) {
+      return {
+        status: "skipped_already_completed",
+        message: "People-first capture already completed for this workspace."
+      };
+    }
+  }
+  const { prompts } = options;
+  const proceed = await prompts.confirm({
+    message: "Name the first person OrgX should know about? (takes ~30 seconds; OrgX will pre-draft a first-touch artifact for them)",
+    initialValue: true
+  });
+  if (prompts.isCancel(proceed)) {
+    return { status: "cancelled", message: "People-first capture cancelled." };
+  }
+  if (!proceed) {
+    return {
+      status: "skipped_declined",
+      message: "Skipped \u2014 run the wizard again any time to add your first person."
+    };
+  }
+  const headlineAnswer = await prompts.text({
+    message: 'Who is this person to you? (one line \u2014 e.g. "prospect at Acme", "design partner", "old teammate")',
+    placeholder: "design partner prospect for OrgX",
+    validate(value) {
+      if (!value || !value.trim()) return "Enter one line.";
+      if (value.trim().length > 160) return "Keep it under 160 chars.";
+      return void 0;
+    }
+  });
+  if (prompts.isCancel(headlineAnswer)) {
+    return { status: "cancelled", message: "People-first capture cancelled." };
+  }
+  const headline = typeof headlineAnswer === "string" ? headlineAnswer.trim() : "";
+  const contextAnswer = await prompts.select({
+    initialValue: "personal",
+    message: "Is this on behalf of a business, or a personal relationship?",
+    options: [
+      { value: "personal", label: "Personal", hint: "no business attached yet" },
+      { value: "business", label: "On behalf of a business", hint: "will also create a Business entity" }
+    ]
+  });
+  if (prompts.isCancel(contextAnswer)) {
+    return { status: "cancelled", message: "People-first capture cancelled." };
+  }
+  const hasBusiness = contextAnswer === "business";
+  let businessName;
+  if (hasBusiness) {
+    const businessAnswer = await prompts.text({
+      message: "Business name?",
+      placeholder: "Acme Treasury",
+      validate(value) {
+        if (!value || !value.trim()) return "Enter the business name.";
+        return void 0;
+      }
+    });
+    if (prompts.isCancel(businessAnswer)) {
+      return { status: "cancelled", message: "People-first capture cancelled." };
+    }
+    businessName = typeof businessAnswer === "string" ? businessAnswer.trim() : void 0;
+  }
+  const nameAnswer = await prompts.text({
+    message: "Their name?",
+    placeholder: "Laura Chen",
+    validate(value) {
+      if (!value || !value.trim()) return "Enter a display name.";
+      return void 0;
+    }
+  });
+  if (prompts.isCancel(nameAnswer)) {
+    return { status: "cancelled", message: "People-first capture cancelled." };
+  }
+  const displayName = typeof nameAnswer === "string" ? nameAnswer.trim() : "";
+  const contactAnswer = await prompts.text({
+    message: "How do you reach them? (email, LinkedIn URL, or phone \u2014 comma-separated, at least one)",
+    placeholder: "laura@acme.com, linkedin.com/in/laurachen",
+    validate(value) {
+      if (!value || !value.trim()) return "Enter at least one contact.";
+      const parsed = parseContactChannels(value);
+      if (parsed.length === 0) return "Could not parse any contact channels.";
+      return void 0;
+    }
+  });
+  if (prompts.isCancel(contactAnswer)) {
+    return { status: "cancelled", message: "People-first capture cancelled." };
+  }
+  const contactChannels = parseContactChannels(
+    typeof contactAnswer === "string" ? contactAnswer : ""
+  );
+  const stageAnswer = await prompts.select({
+    initialValue: "prospect",
+    message: "What stage is the relationship?",
+    options: RELATIONSHIP_STAGE_OPTIONS.map((opt) => ({
+      value: opt.value,
+      label: opt.label,
+      ...opt.hint ? { hint: opt.hint } : {}
+    }))
+  });
+  if (prompts.isCancel(stageAnswer)) {
+    return { status: "cancelled", message: "People-first capture cancelled." };
+  }
+  const relationshipStage = stageAnswer;
+  const trustAnswer = await prompts.select({
+    initialValue: "cold",
+    message: "How would you describe the trust level right now?",
+    options: TRUST_TIER_OPTIONS.map((opt) => ({
+      value: opt.value,
+      label: opt.label,
+      ...opt.hint ? { hint: opt.hint } : {}
+    }))
+  });
+  if (prompts.isCancel(trustAnswer)) {
+    return { status: "cancelled", message: "People-first capture cancelled." };
+  }
+  const trustTier = trustAnswer;
+  const innerCircleAnswer = await prompts.confirm({
+    message: "Mark this person as inner-circle? (affects tone of drafted artifacts)",
+    initialValue: false
+  });
+  if (prompts.isCancel(innerCircleAnswer)) {
+    return { status: "cancelled", message: "People-first capture cancelled." };
+  }
+  const innerCircle = Boolean(innerCircleAnswer);
+  const goalAnswer = await prompts.text({
+    message: "Which matters most right now? (one line \u2014 this becomes their Goal)",
+    placeholder: "agree on first pilot scope by May 3",
+    validate(value) {
+      if (!value || !value.trim()) return "Enter one line.";
+      return void 0;
+    }
+  });
+  if (prompts.isCancel(goalAnswer)) {
+    return { status: "cancelled", message: "People-first capture cancelled." };
+  }
+  const goalTitle = typeof goalAnswer === "string" ? goalAnswer.trim() : "";
+  let businessIntent;
+  if (hasBusiness && relationshipStage === "conversation") {
+    const intentAnswer = await prompts.select({
+      initialValue: "client",
+      message: "Is this person an investor in this business, or a client of it?",
+      options: [
+        { value: "client", label: "Client / prospect", hint: "default" },
+        { value: "investor", label: "Investor / advisor" },
+        { value: "unspecified", label: "Unsure / neither" }
+      ]
+    });
+    if (prompts.isCancel(intentAnswer)) {
+      return { status: "cancelled", message: "People-first capture cancelled." };
+    }
+    businessIntent = intentAnswer;
+  }
+  let businessId;
+  if (hasBusiness && businessName) {
+    const businessRes = await postJson(auth, "/v1/businesses", {
+      display_name: businessName,
+      relationship_stage: relationshipStage === "alumni" ? "alumni" : "engaged"
+    });
+    if (!businessRes.ok) {
+      return {
+        status: "failed",
+        message: `${BACKEND_UNREACHABLE_HINT} (businesses: ${businessRes.error})`,
+        error: businessRes.error
+      };
+    }
+    businessId = extractId(businessRes.body) ?? void 0;
+  }
+  const personPayload = {
+    display_name: displayName,
+    headline,
+    relationship_stage: relationshipStage,
+    contact_channels: contactChannels,
+    metadata: {
+      captured_via: "orgx-wizard",
+      inner_circle: innerCircle,
+      trust_tier: trustTier,
+      ...businessIntent ? { business_intent: businessIntent } : {}
+    },
+    ...businessId ? { business_id: businessId } : {}
+  };
+  const personRes = await postJson(auth, "/v1/people", personPayload);
+  if (!personRes.ok) {
+    return {
+      status: "failed",
+      message: `${BACKEND_UNREACHABLE_HINT} (people: ${personRes.error})`,
+      error: personRes.error
+    };
+  }
+  const personId = extractId(personRes.body) ?? void 0;
+  if (!personId) {
+    return {
+      status: "failed",
+      message: `${BACKEND_UNREACHABLE_HINT} (people: missing id in response)`,
+      error: "missing_person_id"
+    };
+  }
+  const goalRes = await postJson(auth, "/v1/goals", {
+    owner_type: "person",
+    owner_id: personId,
+    title: goalTitle
+  });
+  if (!goalRes.ok) {
+    return {
+      status: "failed",
+      message: `${BACKEND_UNREACHABLE_HINT} (goals: ${goalRes.error})`,
+      error: goalRes.error
+    };
+  }
+  const goalId = extractId(goalRes.body) ?? void 0;
+  if (!goalId) {
+    return {
+      status: "failed",
+      message: `${BACKEND_UNREACHABLE_HINT} (goals: missing id in response)`,
+      error: "missing_goal_id"
+    };
+  }
+  const person = {
+    id: personId,
+    display_name: displayName,
+    headline,
+    relationship_stage: relationshipStage,
+    contact_channels: contactChannels,
+    inner_circle: innerCircle,
+    trust_tier: trustTier,
+    ...businessId ? { business_id: businessId } : {},
+    ...businessIntent ? { business_intent: businessIntent } : {}
+  };
+  const goal = {
+    id: goalId,
+    owner_type: "person",
+    owner_id: personId,
+    title: goalTitle
+  };
+  return {
+    status: "completed",
+    message: `Captured ${displayName} in your workspace.`,
+    person,
+    goal
+  };
+}
+
+// src/peopleFirst/templateSelect.ts
+function selectPeopleFirstTemplate(input) {
+  const trustTier = input.trustTier ?? "cold";
+  if (input.innerCircle) {
+    return {
+      persona: "inner_circle",
+      reason: "inner-circle mark set by user",
+      needsBusinessIntentPrompt: false
+    };
+  }
+  switch (input.relationshipStage) {
+    case "stranger":
+    case "prospect":
+      return {
+        persona: "cold_outreach",
+        reason: `stage=${input.relationshipStage} \u2014 cold outreach draft`,
+        needsBusinessIntentPrompt: false
+      };
+    case "conversation": {
+      if (input.hasBusiness) {
+        if (input.businessIntent === "investor") {
+          return {
+            persona: "investor_prep",
+            reason: "conversation + business + investor intent",
+            needsBusinessIntentPrompt: false
+          };
+        }
+        if (input.businessIntent === "client") {
+          return {
+            persona: "client_trust",
+            reason: "conversation + business + client intent",
+            needsBusinessIntentPrompt: false
+          };
+        }
+        return {
+          persona: "client_trust",
+          reason: "conversation + business \u2014 defaulting to client_trust; ask to confirm",
+          needsBusinessIntentPrompt: true
+        };
+      }
+      if (trustTier === "warm" || trustTier === "close") {
+        return {
+          persona: "founder_ally",
+          reason: `conversation + trust=${trustTier} \u2014 founder-ally outreach`,
+          needsBusinessIntentPrompt: false
+        };
+      }
+      return {
+        persona: "cold_outreach",
+        reason: "conversation + cold trust \u2014 treating as cold_outreach",
+        needsBusinessIntentPrompt: false
+      };
+    }
+    case "design_partner":
+    case "active_client":
+      return {
+        persona: "client_trust",
+        reason: `stage=${input.relationshipStage} \u2014 client_trust cadence`,
+        needsBusinessIntentPrompt: false
+      };
+    case "alumni":
+      return {
+        persona: "alumni_touch",
+        reason: "stage=alumni \u2014 alumni_touch rekindle",
+        needsBusinessIntentPrompt: false
+      };
+    case "paused":
+    case "churned":
+      return {
+        persona: "alumni_touch",
+        reason: `stage=${input.relationshipStage} \u2014 treating as alumni_touch for rekindle tone`,
+        needsBusinessIntentPrompt: false
+      };
+  }
+}
+
+// src/lib/people-first-artifact.ts
+async function callDraftEndpoint(auth, body) {
+  try {
+    const res = await fetch(buildOrgxApiUrl("/v1/artifacts/draft", auth.baseUrl), {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${auth.apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!res.ok) {
+      return { ok: false, error: `HTTP ${res.status}` };
+    }
+    const data = await res.json().catch(() => null);
+    return { ok: true, data: data ?? {} };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { ok: false, error: message };
+  }
+}
+async function runPeopleFirstArtifactDraft(options) {
+  if (!options.interactive) {
+    return {
+      status: "skipped_non_interactive",
+      message: "Artifact draft skipped \u2014 not attached to a TTY."
+    };
+  }
+  const auth = await resolveOrgxAuth();
+  if (!auth) {
+    return {
+      status: "failed",
+      message: "Artifact draft needs OrgX auth.",
+      error: "no_auth"
+    };
+  }
+  let businessIntent = options.businessIntent;
+  const { prompts, person } = options;
+  const hasBusiness = Boolean(options.businessName || person.business_id);
+  const preselection = selectPeopleFirstTemplate({
+    relationshipStage: person.relationship_stage,
+    hasBusiness,
+    trustTier: person.trust_tier,
+    innerCircle: person.inner_circle,
+    ...businessIntent ? { businessIntent } : {}
+  });
+  let persona = preselection.persona;
+  if (preselection.needsBusinessIntentPrompt && !businessIntent) {
+    const answer = await prompts.select({
+      initialValue: "client",
+      message: "Is this more of a client-trust update, or investor-prep?",
+      options: [
+        { value: "client", label: "Client trust (default)" },
+        { value: "investor", label: "Investor prep" }
+      ]
+    });
+    if (prompts.isCancel(answer)) {
+      return { status: "cancelled", message: "Artifact draft cancelled." };
+    }
+    businessIntent = answer;
+    persona = selectPeopleFirstTemplate({
+      relationshipStage: person.relationship_stage,
+      hasBusiness,
+      trustTier: person.trust_tier,
+      innerCircle: person.inner_circle,
+      businessIntent
+    }).persona;
+  }
+  const serverResult = await callDraftEndpoint(auth, {
+    template_persona: persona,
+    person_id: person.id,
+    calibration_inputs: {
+      voice_examples: []
+    }
+  });
+  if (!serverResult.ok) {
+    return {
+      status: "failed",
+      message: `Could not draft artifact \u2014 ${serverResult.error}. Check your network / run \`orgx-wizard status\`.`,
+      persona,
+      error: serverResult.error
+    };
+  }
+  return {
+    status: "drafted",
+    message: `Drafted ${persona} artifact for ${person.display_name}.`,
+    persona,
+    ...serverResult.data.artifact_id ? { serverArtifactId: serverResult.data.artifact_id } : {},
+    ...serverResult.data.url ? { serverArtifactUrl: serverResult.data.url } : {}
+  };
+}
+
 // src/spinner.ts
 import ora from "ora";
 import pc2 from "picocolors";
@@ -6174,6 +6775,109 @@ async function maybeInstallOptionalCompanionPlugins(input) {
     ...input.telemetry ? { telemetry: input.telemetry } : {}
   });
 }
+async function maybeRunPeopleFirstCapture(input) {
+  if (!input.interactive || !input.workspace) {
+    return "skipped";
+  }
+  const alreadyCompleted = hasPeopleFirstCaptureCompleted(input.workspace.id);
+  const captureResult = await runPeopleFirstCapture({
+    interactive: input.interactive,
+    workspace: input.workspace,
+    alreadyCompleted,
+    prompts: {
+      cancel: clack.cancel,
+      isCancel: clack.isCancel,
+      text: textPrompt,
+      select: selectPrompt,
+      confirm: clack.confirm
+    }
+  });
+  switch (captureResult.status) {
+    case "skipped_already_completed":
+      return "skipped";
+    case "skipped_non_interactive":
+    case "skipped_no_workspace":
+      return "skipped";
+    case "skipped_declined":
+      console.log(`  ${ICON.skip}  ${pc3.dim(captureResult.message)}`);
+      return "skipped";
+    case "cancelled":
+      return "cancelled";
+    case "failed":
+      console.log(`  ${ICON.warn}  ${pc3.yellow("people-first")}  ${pc3.dim(captureResult.message)}`);
+      return "failed";
+    case "completed":
+      break;
+  }
+  if (!captureResult.person || !captureResult.goal) {
+    return "failed";
+  }
+  console.log(
+    `  ${ICON.ok}  ${pc3.green("people-first")}  ${pc3.dim(
+      `Captured ${captureResult.person.display_name} (${captureResult.person.relationship_stage}).`
+    )}`
+  );
+  const draftResult = await runPeopleFirstArtifactDraft({
+    interactive: input.interactive,
+    person: captureResult.person,
+    prompts: {
+      cancel: clack.cancel,
+      isCancel: clack.isCancel,
+      text: textPrompt,
+      select: selectPrompt,
+      confirm: clack.confirm
+    }
+  });
+  if (draftResult.status === "cancelled") {
+  } else if (draftResult.status === "failed") {
+    console.log(
+      `  ${ICON.warn}  ${pc3.yellow("artifact draft")}  ${pc3.dim(draftResult.message)}`
+    );
+  } else if (draftResult.status === "drafted") {
+    console.log(
+      `  ${ICON.ok}  ${pc3.green("artifact draft")}  ${pc3.dim(
+        `OrgX pre-drafted a ${draftResult.persona ?? "first-touch"} artifact.`
+      )}`
+    );
+  }
+  try {
+    recordPeopleFirstCaptureCompletion({
+      workspaceId: input.workspace.id,
+      completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      ...captureResult.person ? { personId: captureResult.person.id } : {},
+      ...draftResult.persona ? { templatePersona: draftResult.persona } : {}
+    });
+  } catch {
+  }
+  const baseUrl = process.env.ORGX_APP_URL?.trim() || DEFAULT_ORGX_BASE_URL;
+  const commandUrl = `${baseUrl.replace(/\/+$/, "")}/command`;
+  console.log("");
+  console.log(
+    `  ${ICON.ok}  ${pc3.bold(
+      `You brought in ${captureResult.person.display_name}.`
+    )}  ${pc3.dim(
+      `Head to ${commandUrl} to see them in your people list \u2014 OrgX already drafted a first-touch artifact.`
+    )}`
+  );
+  if (input.openInBrowser) {
+    const openResult = openBrowser(commandUrl);
+    if (!openResult.ok && openResult.error) {
+      console.log(`       ${pc3.dim(`(Could not auto-open browser: ${openResult.error})`)}`);
+    }
+  } else {
+    const openAnswer = await clack.confirm({
+      message: `Open ${commandUrl} in your browser now?`,
+      initialValue: true
+    });
+    if (!clack.isCancel(openAnswer) && openAnswer === true) {
+      const openResult = openBrowser(commandUrl);
+      if (!openResult.ok && openResult.error) {
+        console.log(`       ${pc3.dim(`(Could not auto-open browser: ${openResult.error})`)}`);
+      }
+    }
+  }
+  return "completed";
+}
 function printAuthStatus(status) {
   if (!status.configured) {
     console.log(`  ${ICON.warn}  ${pc3.yellow("no account")}   run ${pc3.cyan(`${getCmd()} auth login`)} to connect`);
@@ -6252,12 +6956,12 @@ 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.17" : void 0;
+  const pkgVersion = true ? "0.1.20" : void 0;
   program.version(pkgVersion ?? "unknown", "-V, --version");
   program.hook("preAction", () => {
     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)").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("--open", "After people-first capture, auto-open the OrgX dashboard in your browser.", false).action(async (options) => {
     const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY);
     await safeTrackWizardTelemetry("wizard_started", {
       command: "setup",
@@ -6430,6 +7134,22 @@ async function main() {
       if (workspaceSetup.status === "cancelled") {
         return;
       }
+      if (workspaceSetup.status === "reauth_requested") {
+        console.log("");
+        console.log(
+          `  ${ICON.warn}  ${pc3.yellow("workspace")}  ${pc3.dim("API key authenticated but returned 0 workspaces \u2014 likely an identity mismatch.")}`
+        );
+        console.log(`  ${pc3.cyan(`${getCmd()} auth login`)}  ${pc3.dim("\u2192 re-link via OAuth, then rerun")}  ${pc3.cyan(`${getCmd()} setup`)}`);
+        await safeTrackWizardTelemetry(
+          "workspace_bootstrapped",
+          buildWorkspaceSetupTelemetryProperties(workspaceSetup, {
+            command: "setup",
+            interactive,
+            preset: "standard"
+          })
+        );
+        return;
+      }
       await safeTrackWizardTelemetry(
         "workspace_bootstrapped",
         buildWorkspaceSetupTelemetryProperties(workspaceSetup, {
@@ -6463,6 +7183,14 @@ async function main() {
       } else if (briefResult.status === "failed") {
         console.log(`  ${ICON.warn}  ${pc3.yellow("daily brief")}  ${pc3.dim(briefResult.message)}`);
       }
+      const peopleFirstResult = await maybeRunPeopleFirstCapture({
+        interactive,
+        openInBrowser: Boolean(options.open),
+        workspace: resolvedWorkspace
+      });
+      if (peopleFirstResult === "cancelled") {
+        return;
+      }
       const addOnResult = await maybeConfigureOptionalWorkspaceAddOns({
         interactive,
         telemetry: { command: "setup", preset: "standard" },