@useorgx/wizard 0.1.19 → 0.1.21

package/dist/cli.js

@@ -1389,28 +1389,6 @@ function readWizardState(statePath = ORGX_WIZARD_STATE_PATH) {
   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 });
@@ -4975,6 +4953,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;
@@ -5084,24 +5063,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.",
@@ -5391,7 +5381,357 @@ async function trackWizardTelemetry(event, properties = {}, options = {}) {
   return response?.ok === true;
 }
 
+// src/lib/intents.ts
+var AGENT_SLUGS = [
+  "mark",
+  "eli",
+  "dana",
+  "pace",
+  "sage",
+  "orion",
+  "xandy"
+];
+var INTENT_STATUSES = [
+  "pending",
+  "approved",
+  "adjusted",
+  "archived"
+];
+var AGENT_ROLES = {
+  mark: "Partnerships",
+  eli: "Engineering",
+  dana: "Brand",
+  pace: "Product",
+  sage: "Strategy",
+  orion: "Routing",
+  xandy: "Default"
+};
+var CONFIDENCE_DECIMAL = {
+  low: 0.55,
+  med: 0.78,
+  high: 0.92
+};
+var AGENT_ANSI_256 = {
+  pace: 34,
+  // green
+  eli: 44,
+  // cyan
+  mark: 208,
+  // orange
+  sage: 135,
+  // purple
+  orion: 214,
+  // amber
+  dana: 199,
+  // pink
+  xandy: 37
+  // teal
+};
+function parseAgentSlug(value) {
+  if (typeof value !== "string") return null;
+  return AGENT_SLUGS.includes(value) ? value : null;
+}
+function parseStatus(value) {
+  if (typeof value !== "string") return null;
+  return INTENT_STATUSES.includes(value) ? value : null;
+}
+function parseConfidence(value) {
+  if (value === "low" || value === "med" || value === "high") return value;
+  return "med";
+}
+function parsePlanStep(value) {
+  if (!isRecord(value)) return null;
+  const title = typeof value.title === "string" ? value.title.trim() : "";
+  if (!title) return null;
+  const detail = typeof value.detail === "string" && value.detail.trim().length > 0 ? value.detail : void 0;
+  const agentSlug = parseAgentSlug(value.agent_slug);
+  const step = { title };
+  if (detail !== void 0) step.detail = detail;
+  if (agentSlug !== null) step.agent_slug = agentSlug;
+  return step;
+}
+function parsePlanPreview(value) {
+  if (!isRecord(value)) {
+    return { steps: [], eta: "under a week", confidence: "med" };
+  }
+  const steps = Array.isArray(value.steps) ? value.steps.map(parsePlanStep).filter((step) => step !== null) : [];
+  const eta = typeof value.eta === "string" && value.eta.trim().length > 0 ? value.eta : "under a week";
+  return {
+    steps,
+    eta,
+    confidence: parseConfidence(value.confidence)
+  };
+}
+function parseIntent(value) {
+  if (!isRecord(value)) return null;
+  const id = typeof value.id === "string" ? value.id : null;
+  const workspaceId = typeof value.workspace_id === "string" ? value.workspace_id : null;
+  const slug = typeof value.slug === "string" ? value.slug : null;
+  const text2 = typeof value.text === "string" ? value.text : null;
+  const status = parseStatus(value.status);
+  const createdAt = typeof value.created_at === "string" ? value.created_at : null;
+  const updatedAt = typeof value.updated_at === "string" ? value.updated_at : null;
+  if (!id || !workspaceId || !slug || !text2 || !status || !createdAt || !updatedAt) {
+    return null;
+  }
+  return {
+    id,
+    workspace_id: workspaceId,
+    slug,
+    text: text2,
+    status,
+    suggested_agent_slug: parseAgentSlug(value.suggested_agent_slug),
+    plan_preview: parsePlanPreview(value.plan_preview),
+    approved_at: typeof value.approved_at === "string" ? value.approved_at : null,
+    created_at: createdAt,
+    updated_at: updatedAt
+  };
+}
+async function parseResponseBody4(response) {
+  const text2 = await response.text();
+  if (!text2) return null;
+  try {
+    return JSON.parse(text2);
+  } catch {
+    return text2;
+  }
+}
+function formatHttpError3(status, body) {
+  if (typeof body === "string" && body.trim().length > 0) {
+    return `HTTP ${status}: ${body}`;
+  }
+  if (isRecord(body)) {
+    if (isRecord(body.error)) {
+      const message = typeof body.error.message === "string" ? body.error.message : null;
+      const code = typeof body.error.code === "string" ? body.error.code : null;
+      if (message) return `HTTP ${status} (${code ?? "error"}): ${message}`;
+    }
+    if (typeof body.error === "string" && body.error.trim().length > 0) {
+      return `HTTP ${status}: ${body.error}`;
+    }
+  }
+  return `HTTP ${status}`;
+}
+async function requireOrgxAuth3(options = {}) {
+  const auth = await resolveOrgxAuth(options);
+  if (!auth) {
+    throw new Error(
+      "No OrgX API key configured. Run `orgx-wizard auth login` or `orgx-wizard auth set-key <oxk_...>` first."
+    );
+  }
+  return auth;
+}
+async function createIntent(input, options = {}) {
+  const text2 = input.text.trim();
+  if (!text2) {
+    throw new Error("Intent text is required.");
+  }
+  if (text2.length > 4e3) {
+    throw new Error("Intent text exceeds 4,000 characters.");
+  }
+  const workspaceId = input.workspace_id.trim();
+  if (!workspaceId) {
+    throw new Error("Workspace id is required.");
+  }
+  const auth = await requireOrgxAuth3(options);
+  const url = buildOrgxApiUrl("/v1/intents", auth.baseUrl);
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${auth.apiKey}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ workspace_id: workspaceId, text: text2 }),
+    signal: AbortSignal.timeout(15e3)
+  });
+  const body = await parseResponseBody4(response);
+  if (!response.ok) {
+    throw new Error(
+      `Failed to create intent. ${formatHttpError3(response.status, body)}`
+    );
+  }
+  const intent = parseIntent(body);
+  if (!intent) {
+    throw new Error("OrgX returned an unexpected intent payload.");
+  }
+  return intent;
+}
+async function updateIntent(id, input, options = {}) {
+  const trimmedId = id.trim();
+  if (!trimmedId) {
+    throw new Error("Intent id is required.");
+  }
+  const auth = await requireOrgxAuth3(options);
+  const url = buildOrgxApiUrl(`/v1/intents/${encodeURIComponent(trimmedId)}`, auth.baseUrl);
+  const response = await fetch(url, {
+    method: "PATCH",
+    headers: {
+      Authorization: `Bearer ${auth.apiKey}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(input),
+    signal: AbortSignal.timeout(15e3)
+  });
+  const body = await parseResponseBody4(response);
+  if (!response.ok) {
+    throw new Error(
+      `Failed to update intent. ${formatHttpError3(response.status, body)}`
+    );
+  }
+  const intent = parseIntent(body);
+  if (!intent) {
+    throw new Error("OrgX returned an unexpected intent update payload.");
+  }
+  return intent;
+}
+function buildIntentHandoffUrl(slug, options = {}) {
+  const base = options.baseUrl?.trim() || "https://useorgx.com";
+  const normalized = base.replace(/\/+$/, "");
+  return `${normalized}/command?intent=${encodeURIComponent(slug)}`;
+}
+
+// src/lib/intent-render.ts
+function detectRenderCapabilities(env = process.env) {
+  const noColor = Boolean(env.NO_COLOR && env.NO_COLOR.length > 0);
+  const asciiOnly = (env.LC_ALL ?? "").toUpperCase() === "C" || (env.LANG ?? "").toUpperCase() === "C";
+  return { noColor, asciiOnly };
+}
+function isInteractive(env = process.env, isTTY = Boolean(process.stdout.isTTY)) {
+  if (!isTTY) return false;
+  if (env.CI === "1" || env.CI === "true") return false;
+  if (env.GITHUB_ACTIONS === "true") return false;
+  return true;
+}
+var CSI = "\x1B[";
+function wrap(code, text2, enabled) {
+  if (!enabled) return text2;
+  return `${CSI}${code}m${text2}${CSI}0m`;
+}
+function colorize(text2, ansi256, options = {}) {
+  return wrap(`38;5;${ansi256}`, text2, !options.noColor);
+}
+function bold(text2, options = {}) {
+  return wrap("1", text2, !options.noColor);
+}
+function dim(text2, options = {}) {
+  return wrap("2", text2, !options.noColor);
+}
+function formatConfidence(value) {
+  const bounded = Math.max(0, Math.min(1, value));
+  return bounded.toFixed(2);
+}
+function renderRoutingLine(agent, confidence, options = {}) {
+  const arrow = options.asciiOnly ? "->" : "\u2192";
+  const separator = options.asciiOnly ? " - " : " \xB7 ";
+  const role = AGENT_ROLES[agent];
+  const name = agent.charAt(0).toUpperCase() + agent.slice(1);
+  const coloredName = colorize(name, AGENT_ANSI_256[agent], options);
+  const confidenceLabel = dim("confidence", options);
+  const confidenceValue = formatConfidence(confidence);
+  return `  ${arrow} ${bold(coloredName, options)}${separator}${role}   ${confidenceLabel} ${confidenceValue}`;
+}
+function resolveConfidenceDecimal(plan) {
+  return CONFIDENCE_DECIMAL[plan.confidence];
+}
+function renderPlanPreview(plan, options = {}) {
+  const horizontal = options.asciiOnly ? "-" : "\u2500";
+  const topLeft = options.asciiOnly ? "+" : "\u250C";
+  const topRight = options.asciiOnly ? "+" : "\u2510";
+  const bottomLeft = options.asciiOnly ? "+" : "\u2514";
+  const bottomRight = options.asciiOnly ? "+" : "\u2518";
+  const vertical = options.asciiOnly ? "|" : "\u2502";
+  const steps = plan.steps.map((step, index) => {
+    const number = `${index + 1}.`.padEnd(3, " ");
+    return `${number} ${step.title}`;
+  });
+  const etaLine = `ETA ${plan.eta}`;
+  const lines = [...steps, "", etaLine];
+  const label = "Plan preview";
+  const contentWidth = Math.max(
+    // Keep enough room for the top-chrome label plus its "─ " prefix and
+    // a minimum trailing dash so the border visually wraps the label.
+    label.length + 4,
+    ...lines.map((line) => line.length)
+  );
+  const innerWidth = contentWidth + 2;
+  const leadingDashes = horizontal.repeat(1);
+  const trailingDashes = horizontal.repeat(
+    Math.max(1, innerWidth - label.length - 3)
+    // leading dash + 2 spaces
+  );
+  const top = `${topLeft}${leadingDashes} ${label} ${trailingDashes}${topRight}`;
+  const body = lines.map((line) => {
+    const padded = line.padEnd(contentWidth, " ");
+    return `${vertical} ${padded} ${vertical}`;
+  }).join("\n");
+  const bottom = `${bottomLeft}${horizontal.repeat(innerWidth)}${bottomRight}`;
+  return [top, body, bottom].join("\n");
+}
+var TONE_ANSI = {
+  primary: 190,
+  // lime (--ox-primary)
+  warning: 214,
+  // amber (adjust)
+  danger: 203,
+  // rose (archive)
+  neutral: 244
+  // bright black (quit)
+};
+function renderHotkeyBar(entries, options = {}) {
+  const prefix = options.asciiOnly ? ">>" : ">>";
+  const segments = entries.map((entry) => {
+    const tone = entry.tone ?? "neutral";
+    const keyLabel = `[${entry.key.toUpperCase()}]`;
+    const coloredKey = colorize(keyLabel, TONE_ANSI[tone], options);
+    return `${coloredKey}${entry.label}`;
+  });
+  return `${prefix} ${segments.join("   ")}`;
+}
+var DEFAULT_HOTKEYS = [
+  { key: "a", label: "pprove", tone: "primary" },
+  { key: "e", label: "dit in browser", tone: "warning" },
+  { key: "x", label: "archive", tone: "danger" },
+  { key: "q", label: "uit", tone: "neutral" }
+];
+function normalizeHotkey(input) {
+  const trimmed = input.trim().toLowerCase();
+  if (trimmed.length === 0) return null;
+  const ch = trimmed.charAt(0);
+  switch (ch) {
+    case "a":
+      return "approve";
+    case "e":
+      return "edit";
+    case "x":
+      return "archive";
+    case "q":
+      return "quit";
+    default:
+      return null;
+  }
+}
+
 // src/lib/daily-brief-onboarding.ts
+function extractErrorHint(body) {
+  if (!body) return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(body);
+  } catch {
+    return body.slice(0, 160);
+  }
+  if (!parsed || typeof parsed !== "object") return null;
+  const obj = parsed;
+  const err = obj.error;
+  if (typeof err === "string") return err;
+  if (err && typeof err === "object") {
+    const message = err.message;
+    if (typeof message === "string") return message;
+    const code = err.code;
+    if (typeof code === "string") return code;
+  }
+  return null;
+}
 var BASELINE_PROMPTS = [
   { task_type: "code_review", label: "Code review", placeholder: "20" },
   { task_type: "prd_draft", label: "PRD draft", placeholder: "45" },
@@ -5551,9 +5891,10 @@ async function runDailyBriefOnboarding(options) {
   });
   if (!commitResponse.ok) {
     const text2 = await commitResponse.text().catch(() => "");
+    const hint = extractErrorHint(text2) ?? `HTTP ${commitResponse.status}`;
     return {
       status: "failed",
-      message: "Could not commit onboarding capture.",
+      message: `Could not commit onboarding capture \u2014 ${hint}`,
       error: `HTTP ${commitResponse.status}: ${text2.slice(0, 200)}`
     };
   }
@@ -5584,536 +5925,6 @@ 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";
@@ -6508,6 +6319,296 @@ function parseTimeoutSeconds(value) {
   }
   return parsed;
 }
+async function readSingleKey() {
+  const stdin = process.stdin;
+  if (!stdin.isTTY) return null;
+  const previousRawMode = stdin.isRaw === true;
+  return await new Promise((resolve) => {
+    const cleanup = (result) => {
+      stdin.off("data", onData);
+      if (stdin.isTTY) {
+        stdin.setRawMode(previousRawMode);
+      }
+      stdin.pause();
+      resolve(result);
+    };
+    const onData = (chunk) => {
+      const text2 = chunk.toString("utf8");
+      const first = text2.charAt(0);
+      if (first === "" || first === "") {
+        cleanup(null);
+        return;
+      }
+      cleanup(first.toLowerCase());
+    };
+    if (stdin.isTTY) {
+      stdin.setRawMode(true);
+    }
+    stdin.resume();
+    stdin.on("data", onData);
+  });
+}
+function printIntentPreview(intent, baseUrl) {
+  const render = detectRenderCapabilities();
+  const agent = intent.suggested_agent_slug ?? "xandy";
+  const confidence = resolveConfidenceDecimal(intent.plan_preview);
+  console.log("");
+  console.log(renderRoutingLine(agent, confidence, render));
+  console.log("");
+  console.log(renderPlanPreview(intent.plan_preview, render));
+  console.log("");
+  console.log(
+    dim(
+      `  slug ${intent.slug}   handoff ${buildIntentHandoffUrl(intent.slug, { baseUrl })}`,
+      render
+    )
+  );
+  console.log("");
+  console.log(renderHotkeyBar(DEFAULT_HOTKEYS, render));
+}
+async function maybeCaptureSetupIntent(input) {
+  if (!input.interactive || !input.workspace) {
+    return "skipped";
+  }
+  const prompt = await textPrompt({
+    message: "In one line, what do you want OrgX to move first? (blank to skip \u2014 you can start from the dashboard)",
+    placeholder: "e.g. open a warm-intro loop to 50 design-led SaaS founders",
+    validate: (value) => {
+      const trimmed = (value ?? "").trim();
+      if (!trimmed) return void 0;
+      if (trimmed.length > 4e3) return "Keep it under 4,000 characters.";
+      return void 0;
+    }
+  });
+  if (clack.isCancel(prompt)) {
+    return "cancelled";
+  }
+  const intentText = typeof prompt === "string" ? prompt.trim() : "";
+  if (!intentText) {
+    return "skipped";
+  }
+  const spinner = createOrgxSpinner("Routing");
+  spinner.start();
+  let intent;
+  try {
+    intent = await createIntent({
+      workspace_id: input.workspace.id,
+      text: intentText
+    });
+    spinner.stop();
+  } catch (error) {
+    spinner.fail("Could not classify intent.");
+    const message = error instanceof Error ? error.message : String(error);
+    console.log(`  ${ICON.warn}  ${pc3.yellow("intent")}  ${pc3.dim(message)}`);
+    return "failed";
+  }
+  const auth = await resolveOrgxAuth().catch(() => null);
+  const baseUrl = auth?.baseUrl ?? DEFAULT_ORGX_BASE_URL;
+  printIntentPreview(intent, baseUrl);
+  const approveChoice = await clack.confirm({
+    message: "Approve this plan and hand off to OrgX?",
+    initialValue: true
+  });
+  if (clack.isCancel(approveChoice)) {
+    return "cancelled";
+  }
+  if (approveChoice) {
+    const approveSpinner = createOrgxSpinner("Approving");
+    approveSpinner.start();
+    try {
+      await updateIntent(intent.id, { status: "approved" });
+      approveSpinner.stop();
+    } catch (error) {
+      approveSpinner.fail("Approve failed.");
+      const message = error instanceof Error ? error.message : String(error);
+      console.log(`  ${ICON.warn}  ${pc3.yellow("intent")}  ${pc3.dim(message)}`);
+      return "failed";
+    }
+    const handoff2 = buildIntentHandoffUrl(intent.slug, { baseUrl });
+    console.log(`  ${ICON.ok}  ${pc3.green("intent")}     ${pc3.dim(`approved \xB7 ${handoff2}`)}`);
+    return "approved";
+  }
+  const handoff = buildIntentHandoffUrl(intent.slug, { baseUrl });
+  console.log(`  ${ICON.skip}  ${pc3.dim(`intent pending \xB7 ${handoff}`)}`);
+  return "captured";
+}
+async function runIntentCommand(options) {
+  const interactive = isInteractive();
+  let intentText = options.initialText?.trim() ?? "";
+  if (!intentText) {
+    if (!interactive) {
+      console.error(
+        pc3.red("Intent text is required when running non-interactively.")
+      );
+      console.error(
+        pc3.dim('  Example: orgx-wizard intent "launch partner outreach campaign"')
+      );
+      process.exitCode = 1;
+      return;
+    }
+    const prompt = await textPrompt({
+      message: "What do you want to move?",
+      placeholder: "e.g. launch partner outreach campaign",
+      validate: (value) => {
+        const trimmed = (value ?? "").trim();
+        if (!trimmed) return "Intent text cannot be empty.";
+        if (trimmed.length > 4e3) return "Intent text exceeds 4,000 characters.";
+        return void 0;
+      }
+    });
+    if (clack.isCancel(prompt) || typeof prompt !== "string") {
+      console.log(pc3.dim("Cancelled."));
+      return;
+    }
+    intentText = prompt.trim();
+  }
+  let workspaceId = options.workspaceId ?? "";
+  let workspaceName = null;
+  let workspaceBaseUrl = null;
+  if (!workspaceId) {
+    const loadLabel = "Loading current OrgX workspace";
+    const spinner = interactive ? createOrgxSpinner(loadLabel) : null;
+    if (spinner) spinner.start();
+    else console.log(pc3.dim(`${loadLabel}...`));
+    try {
+      const current = await getCurrentWorkspace();
+      if (!current) {
+        if (spinner) spinner.fail("No OrgX workspace is configured.");
+        else console.error(pc3.red("No OrgX workspace is configured."));
+        console.log(
+          pc3.dim("  Run `orgx-wizard workspace create <name>` or pass --workspace <id>.")
+        );
+        process.exitCode = 1;
+        return;
+      }
+      workspaceId = current.id;
+      workspaceName = current.name;
+      if (spinner) spinner.stop();
+    } catch (error) {
+      if (spinner) spinner.fail("Failed to load current workspace.");
+      console.error(
+        pc3.red(error instanceof Error ? error.message : String(error))
+      );
+      process.exitCode = 1;
+      return;
+    }
+  }
+  const classifyLabel = "Routing";
+  const classifySpinner = interactive ? createOrgxSpinner(classifyLabel) : null;
+  if (classifySpinner) classifySpinner.start();
+  else console.log(pc3.dim(`${classifyLabel}...`));
+  let intent;
+  try {
+    intent = await createIntent({ workspace_id: workspaceId, text: intentText });
+    if (classifySpinner) classifySpinner.stop();
+  } catch (error) {
+    if (classifySpinner) classifySpinner.fail("Classification failed.");
+    console.error(
+      pc3.red(error instanceof Error ? error.message : String(error))
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const auth = await resolveOrgxAuth().catch(() => null);
+  const baseUrl = auth?.baseUrl ?? DEFAULT_ORGX_BASE_URL;
+  workspaceBaseUrl = baseUrl;
+  if (options.jsonOutput) {
+    const payload = {
+      intent,
+      handoff_url: buildIntentHandoffUrl(intent.slug, { baseUrl }),
+      workspace: workspaceName ? { id: workspaceId, name: workspaceName } : { id: workspaceId }
+    };
+    console.log(JSON.stringify(payload, null, 2));
+    return;
+  }
+  printIntentPreview(intent, baseUrl);
+  console.log("");
+  if (!interactive) {
+    console.log(
+      pc3.dim(
+        `Run \`orgx-wizard intent --workspace ${workspaceId}\` interactively to approve, edit, or archive.`
+      )
+    );
+    return;
+  }
+  let action = null;
+  while (action === null) {
+    const key = await readSingleKey();
+    if (!key) {
+      action = "quit";
+      break;
+    }
+    action = normalizeHotkey(key);
+    if (action === null) {
+      console.log(
+        pc3.dim(`  Unrecognized key. Press a, e, x, or q.`)
+      );
+    }
+  }
+  switch (action) {
+    case "approve": {
+      const approveLabel = "Approving";
+      const spinner = interactive ? createOrgxSpinner(approveLabel) : null;
+      if (spinner) spinner.start();
+      try {
+        await updateIntent(intent.id, { status: "approved" });
+        if (spinner) spinner.stop();
+      } catch (error) {
+        if (spinner) spinner.fail("Approve failed.");
+        console.error(
+          pc3.red(error instanceof Error ? error.message : String(error))
+        );
+        process.exitCode = 1;
+        return;
+      }
+      const handoff = buildIntentHandoffUrl(intent.slug, { baseUrl: workspaceBaseUrl ?? baseUrl });
+      console.log("");
+      console.log(`${pc3.green("\u2713")} Approved \xB7 ${handoff}`);
+      return;
+    }
+    case "edit": {
+      const handoff = buildIntentHandoffUrl(intent.slug, { baseUrl: workspaceBaseUrl ?? baseUrl });
+      console.log("");
+      console.log(`${pc3.yellow("\u270E")} Opening ${handoff}`);
+      const result = openBrowser(handoff);
+      if (!result.ok) {
+        console.log(pc3.dim(`  Could not launch browser: ${result.error}`));
+        console.log(pc3.dim(`  Visit ${handoff} to finish editing.`));
+      }
+      return;
+    }
+    case "archive": {
+      const archiveLabel = "Archiving";
+      const spinner = interactive ? createOrgxSpinner(archiveLabel) : null;
+      if (spinner) spinner.start();
+      try {
+        await updateIntent(intent.id, { status: "archived" });
+        if (spinner) spinner.stop();
+      } catch (error) {
+        if (spinner) spinner.fail("Archive failed.");
+        console.error(
+          pc3.red(error instanceof Error ? error.message : String(error))
+        );
+        process.exitCode = 1;
+        return;
+      }
+      console.log("");
+      console.log(`${pc3.red("\u2715")} Archived \xB7 intent will not be executed.`);
+      return;
+    }
+    case "quit":
+    default: {
+      console.log("");
+      console.log(pc3.dim("  Exited without saving. Intent remains pending."));
+      console.log(
+        pc3.dim(
+          `  Resume at ${buildIntentHandoffUrl(intent.slug, { baseUrl: workspaceBaseUrl ?? baseUrl })}`
+        )
+      );
+      return;
+    }
+  }
+}
 async function maybeConfigureOptionalWorkspaceAddOns(input) {
   if (!input.interactive || !input.workspace) {
     return "skipped";
@@ -6763,109 +6864,6 @@ 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`);
@@ -6944,12 +6942,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.19" : void 0;
+  const pkgVersion = true ? "0.1.21" : 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)").option("--open", "After people-first capture, auto-open the OrgX dashboard in your browser.", false).action(async (options) => {
+  program.command("setup").description("Add OrgX MCP configs, skills/rules, and companion plugins to detected tools.").option("--preset <name>", "run a setup bundle (currently: founder)").action(async (options) => {
     const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY);
     await safeTrackWizardTelemetry("wizard_started", {
       command: "setup",
@@ -7122,6 +7120,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, {
@@ -7155,12 +7169,11 @@ async function main() {
       } else if (briefResult.status === "failed") {
         console.log(`  ${ICON.warn}  ${pc3.yellow("daily brief")}  ${pc3.dim(briefResult.message)}`);
       }
-      const peopleFirstResult = await maybeRunPeopleFirstCapture({
+      const intentResult = await maybeCaptureSetupIntent({
         interactive,
-        openInBrowser: Boolean(options.open),
         workspace: resolvedWorkspace
       });
-      if (peopleFirstResult === "cancelled") {
+      if (intentResult === "cancelled") {
         return;
       }
       const addOnResult = await maybeConfigureOptionalWorkspaceAddOns({
@@ -7580,6 +7593,17 @@ async function main() {
     persistContinuityDefaults({ workspace: result.workspace });
     printWorkspace(result.workspace);
   });
+  program.command("intent").description(
+    "Capture an intent, preview the classified agent + plan, and approve or hand off to the browser."
+  ).argument("[text...]", "intent text (quotes optional)").option("--workspace <id>", "workspace id override; defaults to the current workspace").option("--json", "emit a JSON summary instead of the box-drawn preview").action(async (textParts, options) => {
+    const initialText = textParts.join(" ").trim();
+    const workspaceId = options.workspace?.trim() ?? "";
+    await runIntentCommand({
+      ...initialText ? { initialText } : {},
+      ...workspaceId ? { workspaceId } : {},
+      jsonOutput: Boolean(options.json)
+    });
+  });
   program.command("doctor").description("Verify local OrgX surface config and optional remote setup status.").action(async () => {
     const spinner = createOrgxSpinner("Running OrgX health check");
     spinner.start();