@useorgx/wizard 0.1.20 → 0.1.22

package/dist/cli.js

@@ -3,7 +3,9 @@
 // src/cli.ts
 import * as clack from "@clack/prompts";
 import { spawnSync as spawnSync3 } from "child_process";
+import { readFileSync as readFileSync3 } from "fs";
 import { hostname } from "os";
+import { resolve } from "path";
 import { Command } from "commander";
 import pc3 from "picocolors";
 
@@ -791,7 +793,7 @@ function parsePairingPollResult(value) {
   };
 }
 function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 async function startBrowserPairing(options, fetchImpl) {
   const data = await fetchJson({
@@ -904,12 +906,12 @@ h1{font-size:1.5rem;color:#b91c1c}p{color:#555;margin-top:.5rem}</style>
 <p>Return to your terminal and try again.</p>
 </div></body></html>`;
 function tryListen(port, hostname2) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     const server = createServer();
     server.once("error", reject);
     server.listen(port, hostname2, () => {
       server.removeListener("error", reject);
-      resolve(server);
+      resolve2(server);
     });
   });
 }
@@ -938,7 +940,7 @@ async function startLocalAuthServer(options) {
   const successHtml = options.successHtml ?? DEFAULT_SUCCESS_HTML;
   const errorHtml = options.errorHtml ?? DEFAULT_ERROR_HTML;
   const { server, port } = await bindServer(options.preferredPort, hostname2);
-  const result = new Promise((resolve, reject) => {
+  const result = new Promise((resolve2, reject) => {
     const timer = setTimeout(() => {
       server.close();
       reject(new Error("Timed out waiting for browser authorization."));
@@ -981,7 +983,7 @@ async function startLocalAuthServer(options) {
       res.writeHead(200, { "Content-Type": "text/html" }).end(successHtml);
       clearTimeout(timer);
       server.close();
-      resolve({ code, state });
+      resolve2({ code, state });
     });
   });
   return { port, result };
@@ -1389,28 +1391,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 });
@@ -4457,7 +4437,7 @@ function formatCommandFailure(command, args, result) {
   return `${command} ${args.join(" ")} failed${result.exitCode >= 0 ? ` with exit code ${result.exitCode}` : ""}${detail ? `: ${detail}` : "."}`;
 }
 async function defaultCommandRunner(command, args) {
-  return await new Promise((resolve) => {
+  return await new Promise((resolve2) => {
     const child = spawn(command, [...args], {
       env: process.env,
       stdio: ["ignore", "pipe", "pipe"]
@@ -4472,7 +4452,7 @@ async function defaultCommandRunner(command, args) {
     });
     child.on("error", (error) => {
       const errorCode = typeof error === "object" && error && "code" in error ? String(error.code) : void 0;
-      resolve({
+      resolve2({
         exitCode: -1,
         stdout,
         stderr,
@@ -4480,7 +4460,7 @@ async function defaultCommandRunner(command, args) {
       });
     });
     child.on("close", (code) => {
-      resolve({
+      resolve2({
         exitCode: code ?? -1,
         stdout,
         stderr
@@ -5403,7 +5383,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" },
@@ -5563,9 +5893,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)}`
     };
   }
@@ -5596,534 +5927,501 @@ 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" }
+// src/lib/self-audit.ts
+import { createHash as createHash3 } from "crypto";
+var SELF_AUDIT_SCHEMA_VERSION = "2026-04-27";
+var AUDIT_DIMENSIONS = [
+  "queryability",
+  "proof_density",
+  "loop_closure",
+  "context_debt",
+  "autonomy_readiness",
+  "roi_visibility"
 ];
-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 clampScore(value) {
+  return Math.max(0, Math.min(100, Math.round(value)));
+}
+function ratio(numerator, denominator, fallback = 0) {
+  if (denominator <= 0) return fallback;
+  return numerator / denominator;
+}
+function includesAny(value, patterns) {
+  return patterns.some((pattern) => pattern.test(value));
+}
+function classifyLine(line) {
+  const normalized = line.trim();
+  if (!normalized) return null;
+  if (/^(decision|decided|we decided|d:)\b/i.test(normalized)) return "decision";
+  if (/^(commitment|committed|promise|promised|todo:|we will)\b/i.test(normalized)) return "commitment";
+  if (/^(artifact|receipt|proof|shipped|implemented|commit|pr:)\b/i.test(normalized)) return "artifact";
+  if (/^(open loop|gap|blocker|risk|missing|needs|unresolved)\b/i.test(normalized)) return "open_loop";
+  if (/^(next action|follow[- ]?up|next step|action:)\b/i.test(normalized)) return "next_action";
+  if (/^(outcome|result|impact|metric|adoption)\b/i.test(normalized)) return "outcome";
+  if (/^(roi|economics|token|tokens|cost|saved|time saved|api bill)\b/i.test(normalized)) return "economics";
+  return null;
+}
+function extractFounderLoopItems(imports) {
+  const items = [];
+  for (const source of imports) {
+    const lines = source.text.split(/\r?\n/);
+    lines.forEach((line, index) => {
+      const type = classifyLine(line);
+      if (!type) return;
+      const lineNumber = index + 1;
+      items.push({
+        evidenceRef: `${source.sourceId}:L${lineNumber}`,
+        lineNumber,
+        sourceId: source.sourceId,
+        sourceLabel: source.sourceLabel,
+        text: line.trim(),
+        type
+      });
+    });
   }
+  return items;
+}
+function buildSelfAuditSignals(imports, items, options = {}) {
+  const allText = imports.map((source) => source.text).join("\n");
+  const lower = allText.toLowerCase();
+  const decisions = items.filter((item) => item.type === "decision");
+  const artifacts = items.filter((item) => item.type === "artifact");
+  const commitments = items.filter((item) => item.type === "commitment");
+  const nextActions = items.filter((item) => item.type === "next_action");
+  const outcomes = items.filter((item) => item.type === "outcome");
+  const economics = items.filter((item) => item.type === "economics");
+  const proofMentions = (lower.match(/\b(proof|verified|verification|receipt|quality score|artifact)\b/g) ?? []).length;
+  const ownerMentions = (lower.match(/\b(owner|dri|responsible|agent:|founder)\b/g) ?? []).length;
+  const artifactNextActionMentions = artifacts.filter(
+    (item) => includesAny(item.text.toLowerCase(), [/\bnext action\b/, /\bfollow[- ]?up\b/, /\brollback\b/])
+  ).length;
+  const writebackMentions = (lower.match(/\b(approve|approved|writeback|rollback|create task|follow-up task)\b/g) ?? []).length;
+  const repeatedContextPrompts = (lower.match(/\b(recap|catch you up|context again|restate|reread|remind me)\b/g) ?? []).length;
+  return {
+    approvedWritebackTargets: Math.min(3, writebackMentions),
+    artifactsWithNextActions: Math.min(artifacts.length, nextActions.length + artifactNextActionMentions),
+    artifactsWithOwners: Math.min(artifacts.length, ownerMentions),
+    completedWorkItems: artifacts.length,
+    completedWorkWithProof: Math.min(artifacts.length, proofMentions),
+    connectedSources: Math.max(options.connectedSources?.length ?? 0, imports.length),
+    decisionsWithEvidence: decisions.length,
+    economicSignals: economics.length + (lower.includes("token") || lower.includes("cost") || lower.includes("saved") ? 1 : 0),
+    missingSources: options.missingSources?.length ?? 0,
+    openLoops: items.filter((item) => item.type === "open_loop").length,
+    outcomeLinkedItems: outcomes.length,
+    repeatedContextPrompts,
+    totalArtifacts: artifacts.length,
+    totalContextItems: Math.max(items.length, allText.split(/\s+/).filter(Boolean).length),
+    totalDecisions: decisions.length,
+    unresolvedCommitments: Math.max(0, commitments.length - nextActions.length - outcomes.length)
+  };
 }
-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 });
+function scoreSelfAudit(signals) {
+  const queryability = clampScore(
+    30 + ratio(signals.decisionsWithEvidence, Math.max(1, signals.totalDecisions), 0) * 25 + Math.min(20, signals.connectedSources * 5) + Math.min(30, (signals.totalArtifacts + signals.outcomeLinkedItems + signals.approvedWritebackTargets) * 5)
+  );
+  const proofDensity = clampScore(
+    30 + ratio(signals.completedWorkWithProof, Math.max(1, signals.completedWorkItems), 0) * 35 + ratio(signals.artifactsWithOwners, Math.max(1, signals.totalArtifacts), 0) * 20 + ratio(signals.artifactsWithNextActions, Math.max(1, signals.totalArtifacts), 0) * 15
+  );
+  const loopClosure = clampScore(
+    40 + Math.min(25, signals.outcomeLinkedItems * 25) + Math.min(35, signals.approvedWritebackTargets * 20) + (signals.openLoops === 0 ? 15 : Math.max(0, 15 - signals.openLoops * 3))
+  );
+  const contextDebt = clampScore(
+    100 - Math.min(35, signals.repeatedContextPrompts * 10) - Math.min(35, signals.openLoops * 6) - Math.min(20, signals.missingSources * 4) - Math.min(10, signals.unresolvedCommitments * 3)
+  );
+  const autonomyReadiness = clampScore(
+    35 + Math.min(30, signals.approvedWritebackTargets * 15) + Math.min(20, signals.completedWorkWithProof * 5) + (signals.openLoops <= 1 ? 15 : 5)
+  );
+  const roiVisibility = clampScore(
+    30 + Math.min(40, signals.economicSignals * 18) + Math.min(25, signals.outcomeLinkedItems * 25) + Math.min(10, signals.completedWorkWithProof * 3)
+  );
+  return {
+    autonomy_readiness: autonomyReadiness,
+    context_debt: contextDebt,
+    loop_closure: loopClosure,
+    proof_density: proofDensity,
+    queryability,
+    roi_visibility: roiVisibility
+  };
+}
+function buildFindings(scores, signals) {
+  const findings = [];
+  for (const dimension of AUDIT_DIMENSIONS) {
+    const score = scores[dimension];
+    if (score >= 95) {
+      findings.push({
+        dimension,
+        evidence: `Score ${score}/100 meets the Phase 2 target.`,
+        recommendation: "Keep this dimension gated by evidence so the score stays earned.",
+        severity: "info",
+        title: `${dimension.replace(/_/g, " ")} is at the 95+ target`
+      });
+      continue;
     }
+    const recommendationByDimension = {
+      autonomy_readiness: "Keep writeback approval-gated and add rollback references to every generated action.",
+      context_debt: "Reduce repeated context prompts and close unresolved open loops with task or decision artifacts.",
+      loop_closure: "Add outcome references and approved follow-up writebacks so planning changes after execution.",
+      proof_density: "Attach owners, next actions, and verification proof to every completed work artifact.",
+      queryability: "Add cited decisions, artifacts, connected sources, and retrieval scope to the audit output.",
+      roi_visibility: "Add token/time/cost evidence plus an outcome review so ROI is not a narrative claim."
+    };
+    findings.push({
+      dimension,
+      evidence: `Score ${score}/100. Signals: ${JSON.stringify({
+        approvedWritebackTargets: signals.approvedWritebackTargets,
+        completedWorkWithProof: signals.completedWorkWithProof,
+        economicSignals: signals.economicSignals,
+        openLoops: signals.openLoops,
+        outcomeLinkedItems: signals.outcomeLinkedItems,
+        repeatedContextPrompts: signals.repeatedContextPrompts
+      })}`,
+      recommendation: recommendationByDimension[dimension],
+      severity: score < 60 ? "critical" : "warning",
+      title: `${dimension.replace(/_/g, " ")} needs evidence before it can be called 95+`
+    });
   }
-  return channels;
+  return findings;
 }
-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;
+function buildSelfCritique(scores) {
+  return AUDIT_DIMENSIONS.map((dimension) => {
+    const score = scores[dimension];
+    return {
+      dimension,
+      gap: score >= 95 ? "No score gap. Preserve evidence and regression-test this dimension." : `Needs ${95 - score} more points of verified product evidence before claiming 95+.`,
+      passed: score >= 95,
+      score,
+      target: 95
+    };
+  });
+}
+function hashPlanPayload(payload) {
+  return createHash3("sha256").update(JSON.stringify(payload)).digest("hex");
+}
+function buildSelfAuditPlan(input) {
+  if (input.imports.length === 0) {
+    throw new Error("At least one AI-session import is required to run the Founder Loop audit.");
+  }
+  const items = extractFounderLoopItems(input.imports);
+  const connectedSources = input.connectedSources ?? input.imports.map((source) => source.sourceLabel);
+  const missingSources = input.missingSources ?? [];
+  const signals = buildSelfAuditSignals(input.imports, items, {
+    connectedSources,
+    missingSources
+  });
+  const scores = scoreSelfAudit(signals);
+  const evidenceRefs = items.slice(0, 12).map((item) => item.evidenceRef);
+  const decisions = items.filter((item) => item.type === "decision");
+  const nextAction = items.find((item) => item.type === "next_action");
+  const basePlan = {
+    artifact_type: "ai_native_self_audit_plan",
+    audit_scope: {
+      connected_sources: connectedSources,
+      loop: "founder",
+      missing_sources: missingSources,
+      time_window_days: input.timeWindowDays ?? 30
+    },
+    extracted_items: items,
+    findings: buildFindings(scores, signals),
+    generated_at: input.generatedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    recommended_follow_up: {
+      rollback: "Delete or close the generated OrgX follow-up task if the founder rejects the audit recommendation.",
+      summary: nextAction?.text ?? "Review the audit findings, approve one follow-up action, and attach proof after execution.",
+      title: "Review AI-native self-audit findings and approve first follow-up"
+    },
+    recommended_initiative: {
+      summary: "Generated by @useorgx/wizard audit to close the first Founder Loop from AI-session context, proof artifacts, approved writeback, and outcome review.",
+      title: `Close Founder Loop: ${input.workspace.name} AI-native operating loop`,
+      workstreams: [
+        {
+          purpose: "Capture AI-session context, decisions, commitments, and open loops.",
+          tasks: [
+            {
+              proof_requirement: "AI-session import with cited evidence references.",
+              title: "Import founder AI-session context"
+            }
+          ],
+          title: "Founder Context Ingest"
+        },
+        {
+          purpose: "Turn completed work into artifacts with owners, proof, and next actions.",
+          tasks: [
+            {
+              proof_requirement: "Artifact metadata includes owner, evidence refs, and retrieval scope.",
+              title: "Attach proof artifacts to completed work"
+            }
+          ],
+          title: "Proof Chain"
+        },
+        {
+          purpose: "Write one approved follow-up action into OrgX with rollback context.",
+          tasks: [
+            {
+              proof_requirement: "Approved OrgX task with rollback and evidence references.",
+              title: "Approve first OrgX follow-up writeback"
+            }
+          ],
+          title: "Safe Writeback"
+        },
+        {
+          purpose: "Record outcome and economics so the next plan learns from execution.",
+          tasks: [
+            {
+              proof_requirement: "Founder review with time/token/value estimate and attribution confidence.",
+              title: "Record outcome and economics review"
+            }
+          ],
+          title: "Outcome Review"
+        }
+      ]
+    },
+    safe_writeback_plan: [
+      {
+        action: "create_follow_up_task",
+        approval: "required",
+        rollback: "Delete or close the generated task and preserve the audit artifact as a rejected recommendation.",
+        target: "orgx"
       }
-    }
-    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 };
+    ],
+    schema_version: SELF_AUDIT_SCHEMA_VERSION,
+    scores,
+    self_critique: buildSelfCritique(scores),
+    signals,
+    workspace: input.workspace
+  };
+  const invariant = {
+    decision_refs: decisions.map((item) => item.evidenceRef),
+    evidence_refs: evidenceRefs,
+    goal_ref: `workspace:${input.workspace.id}:ai-native-self-audit`,
+    next_action_ref: nextAction?.evidenceRef ?? "manual-next-action:review-audit",
+    owner_ref: "founder:dri",
+    proof_requirement: "verification",
+    retrieval_scope: "Retrieve the imported AI-session context, extracted Founder Loop items, audit scores, findings, writeback plan, and outcome review."
+  };
+  const artifactHash = hashPlanPayload({ ...basePlan, artifact_invariant: invariant });
+  return {
+    ...basePlan,
+    artifact_hash: artifactHash,
+    artifact_invariant: invariant
+  };
+}
+function renderSelfAuditMarkdown(plan) {
+  const lines = [
+    "# AI-Native Founder Loop Self-Audit",
+    "",
+    `Generated: ${plan.generated_at}`,
+    `Workspace: ${plan.workspace.name} (${plan.workspace.id})`,
+    `Artifact hash: ${plan.artifact_hash}`,
+    "",
+    "## Scores",
+    "",
+    "| Dimension | Score | Target | Status |",
+    "| --- | ---: | ---: | --- |",
+    ...AUDIT_DIMENSIONS.map((dimension) => {
+      const score = plan.scores[dimension];
+      return `| ${dimension.replace(/_/g, " ")} | ${score} | 95 | ${score >= 95 ? "pass" : "gap"} |`;
+    }),
+    "",
+    "## Self-Critique",
+    "",
+    ...plan.self_critique.map((item) => `- ${item.dimension}: ${item.gap}`),
+    "",
+    "## Findings",
+    "",
+    ...plan.findings.map((finding) => [
+      `### ${finding.title}`,
+      "",
+      `- Severity: ${finding.severity}`,
+      `- Evidence: ${finding.evidence}`,
+      `- Recommendation: ${finding.recommendation}`,
+      ""
+    ].join("\n")),
+    "## Extracted Founder Loop Items",
+    "",
+    ...plan.extracted_items.map((item) => `- ${item.type}: ${item.text} (${item.evidenceRef})`),
+    "",
+    "## Recommended Initiative",
+    "",
+    `Title: ${plan.recommended_initiative.title}`,
+    "",
+    plan.recommended_initiative.summary,
+    "",
+    "## Approved Follow-Up Candidate",
+    "",
+    `Title: ${plan.recommended_follow_up.title}`,
+    "",
+    plan.recommended_follow_up.summary,
+    "",
+    `Rollback: ${plan.recommended_follow_up.rollback}`,
+    "",
+    "## Artifact Invariant",
+    "",
+    "```json",
+    JSON.stringify(plan.artifact_invariant, null, 2),
+    "```",
+    ""
+  ];
+  return lines.join("\n");
+}
+function parseEntityRef(payload) {
+  const entity = isRecord(payload) && isRecord(payload.data) ? payload.data : payload;
+  if (!isRecord(entity)) {
+    throw new Error("OrgX returned an unexpected entity payload.");
+  }
+  const id = typeof entity.id === "string" ? entity.id : "";
+  const title = typeof entity.title === "string" ? entity.title : typeof entity.name === "string" ? entity.name : "";
+  if (!id || !title) {
+    throw new Error("OrgX returned an incomplete entity payload.");
   }
+  return { id, title };
 }
-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;
-    }
+async function parseResponseBody5(response) {
+  const text2 = await response.text();
+  if (!text2) return null;
+  try {
+    return JSON.parse(text2);
+  } catch {
+    return text2;
   }
-  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."
-    };
+function formatHttpError4(status, body) {
+  if (typeof body === "string" && body.trim().length > 0) {
+    return `HTTP ${status}: ${body}`;
   }
-  if (!options.workspace) {
-    return {
-      status: "skipped_no_workspace",
-      message: "People-first capture skipped \u2014 no workspace resolved."
-    };
+  if (isRecord(body) && typeof body.error === "string" && body.error.trim().length > 0) {
+    return `HTTP ${status}: ${body.error}`;
   }
-  if (options.alreadyCompleted) {
-    return {
-      status: "skipped_already_completed",
-      message: "People-first capture already completed for this workspace."
-    };
+  if (isRecord(body) && isRecord(body.error) && typeof body.error.message === "string") {
+    return `HTTP ${status}: ${body.error.message}`;
   }
-  const auth = await resolveOrgxAuth();
-  if (!auth) {
+  return `HTTP ${status}`;
+}
+async function createOrgxEntity(body, options) {
+  if (options.dryRun) {
     return {
-      status: "failed",
-      message: "People-first capture needs OrgX auth.",
-      error: "no_auth"
+      id: `dry-run-${String(body.type ?? "entity")}`,
+      title: String(body.title ?? body.name ?? "Dry-run entity")
     };
   }
-  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 auth = await resolveOrgxAuth(options);
+  if (!auth) {
+    throw new Error("No OrgX API key configured. Run `wizard auth login` before using writeback flags.");
   }
-  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 } : {}
+  const response = await fetch(buildOrgxApiUrl("/entities", auth.baseUrl), {
+    body: JSON.stringify(body),
+    headers: {
+      Authorization: `Bearer ${auth.apiKey}`,
+      "Content-Type": "application/json"
     },
-    ...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
+    method: "POST",
+    signal: AbortSignal.timeout(15e3)
   });
-  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 responseBody = await parseResponseBody5(response);
+  if (!response.ok) {
+    throw new Error(`Failed to create ${String(body.type ?? "entity")}. ${formatHttpError4(response.status, responseBody)}`);
   }
-  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
-  };
+  return parseEntityRef(responseBody);
 }
-
-// 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
-      };
-  }
+async function createAuditArtifact(options) {
+  const { initiativeId, markdown, plan } = options;
+  return createOrgxEntity(
+    {
+      artifact_type: "shared.project_handbook",
+      description: "AI-native Founder Loop self-audit generated by @useorgx/wizard audit.",
+      entity_id: initiativeId,
+      entity_type: "initiative",
+      external_url: `orgx-wizard://audit/${plan.artifact_hash}`,
+      initiative_id: initiativeId,
+      metadata: {
+        ...plan.artifact_invariant,
+        artifact_hash: plan.artifact_hash,
+        atomic_unit_type: "ai_native_self_audit",
+        completion_state: "generated",
+        schema_validated: true,
+        scores: plan.scores
+      },
+      name: `AI-Native Self-Audit: ${plan.workspace.name}`,
+      preview_markdown: markdown.slice(0, 8e3),
+      status: "in_review",
+      type: "artifact",
+      workspace_id: plan.workspace.id
+    },
+    options
+  );
 }
-
-// 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"
+async function createInitiativeFromAuditPlan(options) {
+  const { plan } = options;
+  return createOrgxEntity(
+    {
+      metadata: {
+        artifact_hash: plan.artifact_hash,
+        audit_score_snapshot: plan.scores,
+        source: "ai_native_self_audit",
+        source_artifact_type: "ai_native_self_audit_plan"
       },
-      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 };
-  }
+      status: "active",
+      summary: plan.recommended_initiative.summary,
+      title: plan.recommended_initiative.title,
+      type: "initiative",
+      workspace_id: plan.workspace.id
+    },
+    options
+  );
 }
-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 } : {}
-  };
+async function createAuditFollowUpTask(options) {
+  const { initiativeId, milestoneId, plan, workstreamId } = options;
+  const resolvedWorkstreamId = workstreamId?.trim() || (await createOrgxEntity(
+    {
+      initiative_id: initiativeId,
+      metadata: {
+        artifact_hash: plan.artifact_hash,
+        source: "ai_native_self_audit"
+      },
+      status: "active",
+      summary: "Follow-up workstream created by @useorgx/wizard audit so the approved action has execution context.",
+      title: "AI-native self-audit follow-up",
+      type: "workstream",
+      workspace_id: plan.workspace.id
+    },
+    options
+  )).id;
+  const resolvedMilestoneId = milestoneId?.trim() || (await createOrgxEntity(
+    {
+      initiative_id: initiativeId,
+      metadata: {
+        artifact_hash: plan.artifact_hash,
+        source: "ai_native_self_audit"
+      },
+      status: "planned",
+      summary: "Milestone created by @useorgx/wizard audit so the approved follow-up task has proof-chain hierarchy.",
+      title: "AI-native self-audit follow-up",
+      type: "milestone",
+      workspace_id: plan.workspace.id,
+      workstream_id: resolvedWorkstreamId
+    },
+    options
+  )).id;
+  return createOrgxEntity(
+    {
+      description: `${plan.recommended_follow_up.summary}
+
+Rollback: ${plan.recommended_follow_up.rollback}`,
+      initiative_id: initiativeId,
+      milestone_id: resolvedMilestoneId,
+      metadata: {
+        ...plan.artifact_invariant,
+        artifact_hash: plan.artifact_hash,
+        source: "ai_native_self_audit",
+        source_action: "approved_follow_up_writeback"
+      },
+      priority: "high",
+      status: "todo",
+      title: plan.recommended_follow_up.title,
+      type: "task",
+      workstream_id: resolvedWorkstreamId,
+      workspace_id: plan.workspace.id
+    },
+    options
+  );
 }
 
 // src/spinner.ts
@@ -6226,6 +6524,145 @@ function printPluginMutationReport(report) {
     );
   }
 }
+function formatScoreLine(scores) {
+  return Object.entries(scores).map(([dimension, score]) => `${dimension}=${score}`).join(" ");
+}
+function readAuditInput(options, interactive) {
+  if (options.input?.trim()) {
+    return readFileSync3(resolve(options.input.trim()), "utf8");
+  }
+  if (!process.stdin.isTTY) {
+    return readFileSync3(0, "utf8");
+  }
+  if (!interactive) {
+    throw new Error("Audit input is required. Pass --input <file> or pipe text into wizard audit.");
+  }
+  return textPrompt({
+    message: "Paste a short AI-session summary, decision log, or founder context excerpt",
+    placeholder: "Decision: Founder Loop first. Artifact: proof ledger attached. Next action: ...",
+    validate: (value) => value?.trim().length ? void 0 : "Audit context is required."
+  }).then((value) => {
+    if (clack.isCancel(value) || typeof value !== "string") {
+      clack.cancel("Audit cancelled.");
+      return "";
+    }
+    return value;
+  });
+}
+function requireWriteApproval(options, interactive) {
+  const wantsWrite = Boolean(options.createInitiative || options.attachToInitiative || options.writeFollowUp);
+  if (!wantsWrite || options.yes || options.dryRun) return true;
+  if (!interactive) {
+    throw new Error("Write flags require --yes in non-interactive mode.");
+  }
+  return clack.confirm({
+    message: "Approve OrgX writes for this audit run?"
+  }).then((value) => {
+    if (clack.isCancel(value) || value !== true) {
+      clack.cancel("Audit writeback cancelled.");
+      return false;
+    }
+    return true;
+  });
+}
+async function resolveAuditWorkspace(options) {
+  const explicitId = options.workspaceId?.trim();
+  const explicitName = options.workspaceName?.trim();
+  if (explicitId || explicitName) {
+    return {
+      id: explicitId || "manual-workspace",
+      name: explicitName || explicitId || "Manual workspace"
+    };
+  }
+  try {
+    const workspace = await getCurrentWorkspace();
+    if (workspace) {
+      return {
+        id: workspace.id,
+        name: workspace.name
+      };
+    }
+  } catch {
+  }
+  return {
+    id: "local-workspace",
+    name: "Local workspace"
+  };
+}
+async function runAuditCommand(options) {
+  const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY);
+  const text2 = (await readAuditInput(options, interactive)).trim();
+  if (!text2) return;
+  const workspace = await resolveAuditWorkspace(options);
+  const plan = buildSelfAuditPlan({
+    connectedSources: [
+      options.sourceLabel?.trim() || "Manual AI-session import",
+      ...workspace.id === "local-workspace" ? [] : ["OrgX workspace"]
+    ],
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    imports: [
+      {
+        sourceId: "wizard-audit-input",
+        sourceLabel: options.sourceLabel?.trim() || "Wizard audit input",
+        text: text2
+      }
+    ],
+    missingSources: workspace.id === "local-workspace" ? ["OrgX workspace auth", "automatic AI-session import"] : ["automatic AI-session import"],
+    workspace
+  });
+  const markdown = renderSelfAuditMarkdown(plan);
+  const outputDir = resolve(options.outputDir?.trim() || ".orgx/audits");
+  const timestamp = plan.generated_at.replace(/[:.]/g, "-");
+  const jsonPath = resolve(outputDir, `ai-native-self-audit-${timestamp}.json`);
+  const markdownPath = resolve(outputDir, `ai-native-self-audit-${timestamp}.md`);
+  writeJsonFile(jsonPath, plan);
+  writeTextFile(markdownPath, markdown);
+  if (options.json) {
+    console.log(JSON.stringify({ jsonPath, markdownPath, scores: plan.scores }, null, 2));
+  } else {
+    console.log(`  ${ICON.ok}  ${pc3.green("audit generated")} ${pc3.dim(markdownPath)}`);
+    console.log(`  ${ICON.ok}  ${pc3.green("scores         ")} ${pc3.dim(formatScoreLine(plan.scores))}`);
+    const belowTarget = plan.self_critique.filter((item) => !item.passed);
+    if (belowTarget.length === 0) {
+      console.log(`  ${ICON.ok}  ${pc3.green("score gate     ")} ${pc3.dim("all dimensions at 95+")}`);
+    } else {
+      console.log(`  ${ICON.warn}  ${pc3.yellow("score gate     ")} ${pc3.dim(`${belowTarget.length} dimension${belowTarget.length === 1 ? "" : "s"} below 95`)}`);
+    }
+  }
+  const approved = await requireWriteApproval(options, interactive);
+  if (!approved) return;
+  let targetInitiativeId = options.attachToInitiative?.trim() || "";
+  if (options.createInitiative) {
+    const initiative = await createInitiativeFromAuditPlan({
+      dryRun: Boolean(options.dryRun),
+      plan
+    });
+    targetInitiativeId = initiative.id;
+    console.log(`  ${ICON.ok}  ${pc3.green("initiative    ")} ${pc3.bold(initiative.title)} ${pc3.dim(initiative.id)}`);
+  }
+  if (targetInitiativeId && (options.attachToInitiative || options.createInitiative)) {
+    const artifact = await createAuditArtifact({
+      dryRun: Boolean(options.dryRun),
+      initiativeId: targetInitiativeId,
+      markdown,
+      plan
+    });
+    console.log(`  ${ICON.ok}  ${pc3.green("artifact      ")} ${pc3.bold(artifact.title)} ${pc3.dim(artifact.id)}`);
+  }
+  if (options.writeFollowUp) {
+    if (!targetInitiativeId) {
+      throw new Error("--write-follow-up requires --attach-to-initiative <id> or --create-initiative.");
+    }
+    const followUp = await createAuditFollowUpTask({
+      dryRun: Boolean(options.dryRun),
+      initiativeId: targetInitiativeId,
+      ...options.milestoneId?.trim() ? { milestoneId: options.milestoneId.trim() } : {},
+      plan,
+      ...options.workstreamId?.trim() ? { workstreamId: options.workstreamId.trim() } : {}
+    });
+    console.log(`  ${ICON.ok}  ${pc3.green("follow-up     ")} ${pc3.bold(followUp.title)} ${pc3.dim(followUp.id)}`);
+  }
+}
 async function checkPluginStatusesCompact() {
   const spinner = createOrgxSpinner("Checking OrgX companion plugin status");
   spinner.start();
@@ -6520,6 +6957,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((resolve2) => {
+    const cleanup = (result) => {
+      stdin.off("data", onData);
+      if (stdin.isTTY) {
+        stdin.setRawMode(previousRawMode);
+      }
+      stdin.pause();
+      resolve2(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";
@@ -6775,109 +7502,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`);
@@ -6956,12 +7580,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.20" : void 0;
+  const pkgVersion = true ? "0.1.22" : 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",
@@ -7183,12 +7807,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({
@@ -7608,6 +8231,27 @@ 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("audit").description("Run the AI-native Founder Loop self-audit from pasted or file-based AI-session context.").option("--input <path>", "AI-session transcript or summary file; stdin is used when piped").option("--source-label <label>", "label for the imported AI-session source").option("--workspace-id <id>", "workspace id override; defaults to the current OrgX workspace when authenticated").option("--workspace-name <name>", "workspace name override for local-only audits").option("--output-dir <path>", "directory for generated audit JSON and Markdown", ".orgx/audits").option("--attach-to-initiative <id>", "attach the generated audit artifact to an existing OrgX initiative").option("--create-initiative", "create an OrgX initiative from the generated audit plan").option("--write-follow-up", "create one approval-gated OrgX follow-up task from the audit recommendation").option("--workstream-id <id>", "optional workstream id for the generated follow-up task").option("--milestone-id <id>", "optional milestone id for the generated follow-up task").option("--dry-run", "exercise OrgX write paths without sending writes").option("--yes", "approve OrgX write flags in non-interactive mode").option("--json", "emit a JSON command summary").action(async (options) => {
+    await safeTrackWizardTelemetry("audit_started", {
+      attach_to_initiative: Boolean(options.attachToInitiative),
+      command: "audit",
+      create_initiative: Boolean(options.createInitiative),
+      dry_run: Boolean(options.dryRun),
+      write_follow_up: Boolean(options.writeFollowUp)
+    });
+    await runAuditCommand(options);
+  });
   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();