@useorgx/wizard 0.1.21 → 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 };
@@ -4435,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"]
@@ -4450,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,
@@ -4458,7 +4460,7 @@ async function defaultCommandRunner(command, args) {
       });
     });
     child.on("close", (code) => {
-      resolve({
+      resolve2({
         exitCode: code ?? -1,
         stdout,
         stderr
@@ -5925,6 +5927,503 @@ async function fetchOnboardingState(auth) {
   }
 }
 
+// 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"
+];
+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 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 findings;
+}
+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"
+      }
+    ],
+    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 };
+}
+async function parseResponseBody5(response) {
+  const text2 = await response.text();
+  if (!text2) return null;
+  try {
+    return JSON.parse(text2);
+  } catch {
+    return text2;
+  }
+}
+function formatHttpError4(status, body) {
+  if (typeof body === "string" && body.trim().length > 0) {
+    return `HTTP ${status}: ${body}`;
+  }
+  if (isRecord(body) && typeof body.error === "string" && body.error.trim().length > 0) {
+    return `HTTP ${status}: ${body.error}`;
+  }
+  if (isRecord(body) && isRecord(body.error) && typeof body.error.message === "string") {
+    return `HTTP ${status}: ${body.error.message}`;
+  }
+  return `HTTP ${status}`;
+}
+async function createOrgxEntity(body, options) {
+  if (options.dryRun) {
+    return {
+      id: `dry-run-${String(body.type ?? "entity")}`,
+      title: String(body.title ?? body.name ?? "Dry-run entity")
+    };
+  }
+  const auth = await resolveOrgxAuth(options);
+  if (!auth) {
+    throw new Error("No OrgX API key configured. Run `wizard auth login` before using writeback flags.");
+  }
+  const response = await fetch(buildOrgxApiUrl("/entities", auth.baseUrl), {
+    body: JSON.stringify(body),
+    headers: {
+      Authorization: `Bearer ${auth.apiKey}`,
+      "Content-Type": "application/json"
+    },
+    method: "POST",
+    signal: AbortSignal.timeout(15e3)
+  });
+  const responseBody = await parseResponseBody5(response);
+  if (!response.ok) {
+    throw new Error(`Failed to create ${String(body.type ?? "entity")}. ${formatHttpError4(response.status, responseBody)}`);
+  }
+  return parseEntityRef(responseBody);
+}
+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
+  );
+}
+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"
+      },
+      status: "active",
+      summary: plan.recommended_initiative.summary,
+      title: plan.recommended_initiative.title,
+      type: "initiative",
+      workspace_id: plan.workspace.id
+    },
+    options
+  );
+}
+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
 import ora from "ora";
 import pc2 from "picocolors";
@@ -6025,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();
@@ -6323,14 +6961,14 @@ async function readSingleKey() {
   const stdin = process.stdin;
   if (!stdin.isTTY) return null;
   const previousRawMode = stdin.isRaw === true;
-  return await new Promise((resolve) => {
+  return await new Promise((resolve2) => {
     const cleanup = (result) => {
       stdin.off("data", onData);
       if (stdin.isTTY) {
         stdin.setRawMode(previousRawMode);
       }
       stdin.pause();
-      resolve(result);
+      resolve2(result);
     };
     const onData = (chunk) => {
       const text2 = chunk.toString("utf8");
@@ -6942,7 +7580,7 @@ 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.21" : void 0;
+  const pkgVersion = true ? "0.1.22" : void 0;
   program.version(pkgVersion ?? "unknown", "-V, --version");
   program.hook("preAction", () => {
     console.log(renderBanner(pkgVersion));
@@ -7604,6 +8242,16 @@ async function main() {
       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();