@useorgx/wizard 0.1.47 → 0.1.48

package/README.md

@@ -1,6 +1,9 @@
 # @useorgx/wizard
 
-One-line CLI onboarding that adds OrgX MCP configs, skills/rules, and companion plugins to your local AI tools.
+One-line CLI onboarding and AQ profiling for local AI work. The wizard can add
+OrgX MCP configs, skills/rules, and companion plugins, then scan real AI-session
+receipts to show your current Agentic Quotient, reachable ceiling, and first
+repair that raises execution capacity.
 
 ## Quick Start
 
@@ -23,6 +26,9 @@ The wizard modifies local tool configuration only. Depending on the command, it
 ## Commands
 
 - `setup` adds OrgX MCP configs, standalone skills/rules, and companion plugins to detected AI tools. When OrgX auth is available in an interactive shell, it guides workspace selection or creation, can create the user's first live OrgX initiative, creates a starter onboarding task under that initiative, and prints a handoff prompt for the configured AI tool of choice. The founder preset preplans plugin installs before it writes standalone skills so plugin-backed hosts do not get duplicate standalone assets in the same run.
+- `work-graph profile --from all --publish --public-share` runs AQ from recent AI-work receipts, publishes a redacted profile, and prints the first AQ-lifting repair to execute next.
+- `work-graph preview --from all` shows the AQ readout locally without publishing.
+- `work-graph runtime-event --source codex|claude --summary "..."` lets an agent write public-safe runtime evidence that the next AQ profile can collect.
 - `surface list` shows supported surfaces and current status.
 - `surface add <name>` patches a specific surface.
 - `surface remove <name>` removes OrgX-managed config from a specific surface.
@@ -63,6 +69,7 @@ The wizard modifies local tool configuration only. Depending on the command, it
 - If the selected workspace has no remembered setup initiative, `wizard setup` offers to create a first initiative, defaulting to `Make OrgX useful on this machine`. It then creates the onboarding workstream and starter task inside that initiative so setup ends with a concrete next action instead of a blank workspace.
 - Repeated setup runs are intentionally quiet. Daily Brief can be configured with defaults, customized, or skipped; skips for Daily Brief, first initiative creation, onboarding task creation, agent roster setup, and the first intent prompt are remembered per workspace so the wizard does not ask again on every run.
 - After the first initiative is ready, setup prints the `/live/<initiative>` URL and a copyable prompt for the user's configured AI tool: continue the initiative, show the next action, and start with the onboarding task.
+- The AQ loop is: run profile, claim the public Work Graph, start the selected repair quest in OrgX, attach proof, rerun the profile, and compare the AQ delta.
 - `wizard workspace current` reads the current OrgX workspace from `GET /api/v1/workspaces/current`, with a fallback to workspace listing if that route is unavailable.
 - `wizard workspace list` lists all accessible workspaces.
 - `wizard workspace create "Founders" --description "Initial OrgX workspace"` creates a new workspace through `POST /api/entities`.

package/dist/cli.js

@@ -3163,6 +3163,9 @@ var CODEX_PLUGIN_SYNC_SPEC = {
     { localPath: ".codex-plugin", remotePath: ".codex-plugin" },
     { localPath: ".mcp.json", remotePath: ".mcp.json" },
     { localPath: "assets", remotePath: "assets" },
+    // Deliver the runtime hooks (Work Graph reconcile + execution-graph emit)
+    // so the WEG keystone actually installs for Codex, not just Cursor/Claude.
+    { localPath: "hooks", remotePath: "hooks" },
     { localPath: "skills", remotePath: "skills" }
   ]
 };
@@ -12006,11 +12009,19 @@ function renderWorkGraphShareables(report, options) {
   lines.push("");
   const aq = report.agentic_quotient;
   const topQuest = aq.repair_quests[0];
+  const strongestTrail = markdownPublicTrails(report)[0];
+  const firstMove = topQuest ? `${topQuest.title} (+${topQuest.expected_aq_lift} AQ): ${topQuest.reason}` : "Claim the profile and turn the strongest evidence path into owner-visible work with linked proof.";
   lines.push("Suggested share copy:");
   lines.push(`- AQ ${aq.aq}. Stack ${aq.stack_score}. Durable ${aq.durability_score}. Gap ${aq.agentic_gap}. ${aq.archetype.label}. Receipts attached.`);
   lines.push(`- Just ran my AQ. ${topQuest ? `Next repair: ${topQuest.title} (+${topQuest.expected_aq_lift} AQ).` : "The gap is the game."}`);
   lines.push(`- Receipts > vibes. AQ ${aq.aq} with ${report.impact_projection.time_saved_hours_per_week}h/week recoverable.`);
   lines.push("");
+  lines.push("First executable move:");
+  lines.push(`- ${firstMove}`);
+  if (strongestTrail) {
+    lines.push(`- Evidence path: ${markdownPublicTitle(strongestTrail.title, "Top work loop")}`);
+  }
+  lines.push("");
   return lines;
 }
 function renderWorkGraphMarkdown(report, options = {}) {
@@ -12137,6 +12148,17 @@ function renderWorkGraphMarkdown(report, options = {}) {
   lines.push(report.agentic_quotient.archetype.roast);
   lines.push(report.agentic_quotient.archetype.truth);
   lines.push("");
+  if (report.agentic_quotient.repair_quests[0]) {
+    const quest = report.agentic_quotient.repair_quests[0];
+    const primaryTrail = markdownPublicTrails(report)[0];
+    lines.push("First executable move:");
+    lines.push(`- ${quest.title} (+${quest.expected_aq_lift} AQ): ${quest.reason}`);
+    if (primaryTrail) {
+      lines.push(`- Starts from: ${markdownPublicTitle(primaryTrail.title, "Top work loop")}`);
+    }
+    lines.push(`- Why it matters: moves AQ ${report.agentic_quotient.aq} toward ${report.agentic_quotient.ceiling} by closing proof, source, or writeback gaps.`);
+    lines.push("");
+  }
   if (report.agentic_quotient.repair_quests.length > 0) {
     lines.push("Repair quests:");
     for (const quest of report.agentic_quotient.repair_quests) {
@@ -12760,6 +12782,7 @@ import { copyFileSync, existsSync as existsSync9, mkdirSync as mkdirSync3 } from
 import { homedir as homedir3 } from "os";
 import { dirname as dirname4, join as join7 } from "path";
 var HOOK_MARKER = "orgx-session-hook.mjs";
+var EMIT_HOOK_MARKER = "orgx-emit-execution-graph.mjs";
 var HOOK_EVENTS = ["SessionStart", "UserPromptSubmit", "PreToolUse", "PostToolUse", "PermissionRequest", "Stop"];
 var CLAUDE_HOOK_EVENTS = ["SessionStart", "UserPromptSubmit", "PreToolUse", "PostToolUse", "SubagentStop", "Stop", "SessionEnd"];
 function defaultPaths(options = {}) {
@@ -12769,6 +12792,7 @@ function defaultPaths(options = {}) {
     codexConfigPath: options.codexConfigPath ?? CODEX_CONFIG_PATH ?? join7(CODEX_DIR, "config.toml"),
     codexHooksPath: options.codexHooksPath ?? join7(CODEX_DIR, "hooks.json"),
     hookScriptPath: options.hookScriptPath ?? join7(hookDir, HOOK_MARKER),
+    emitHookScriptPath: options.emitHookScriptPath ?? join7(hookDir, EMIT_HOOK_MARKER),
     outboxPath: options.outboxPath ?? join7(hookDir, "events.jsonl")
   };
 }
@@ -12889,6 +12913,140 @@ function buildHookCommand(params) {
     `--outbox=${params.outboxPath}`
   ].join(" ");
 }
+function buildExecutionGraphEmitScriptContent() {
+  return `#!/usr/bin/env node
+import { readFileSync } from "node:fs";
+
+function parseArgs(argv) {
+  const args = {};
+  for (const arg of argv) {
+    if (!arg.startsWith("--")) continue;
+    const i = arg.indexOf("=");
+    if (i < 0) args[arg.slice(2)] = "true";
+    else args[arg.slice(2, i)] = arg.slice(i + 1);
+  }
+  return args;
+}
+function truthy(v) {
+  return typeof v === "string" && ["1", "true", "yes", "on"].includes(v.toLowerCase());
+}
+function pick() {
+  for (let i = 0; i < arguments.length; i++) {
+    const v = arguments[i];
+    if (typeof v === "string" && v.trim()) return v.trim();
+  }
+  return undefined;
+}
+function clamp(s, m) {
+  return typeof s === "string" ? s.slice(0, m) : undefined;
+}
+async function readStdin() {
+  try {
+    const c = [];
+    for await (const ch of process.stdin) c.push(Buffer.from(ch));
+    return Buffer.concat(c).toString("utf8");
+  } catch (e) {
+    return "";
+  }
+}
+function jsonl(raw) {
+  const out = [];
+  if (typeof raw !== "string") return out;
+  for (const line of raw.split(String.fromCharCode(10))) {
+    const t = line.trim();
+    if (!t) continue;
+    try { out.push(JSON.parse(t)); } catch (e) {}
+  }
+  return out;
+}
+function blocks(entry) {
+  const m = entry && (entry.message || entry);
+  const c = m && m.content;
+  return Array.isArray(c) ? c : [];
+}
+function derive(entries, max) {
+  const errs = new Map();
+  for (const e of entries) for (const b of blocks(e)) {
+    if (b && b.type === "tool_result" && b.tool_use_id) errs.set(b.tool_use_id, !!b.is_error);
+  }
+  const steps = [];
+  for (const e of entries) for (const b of blocks(e)) {
+    if (b && b.type === "tool_use") steps.push({ id: b.id, name: typeof b.name === "string" ? b.name : "tool" });
+  }
+  const nodes = [{ id: "session", type: "task", title: "Claude Code session", status: "completed", requires_evidence: false }];
+  const capped = steps.slice(-(max - 1));
+  for (let i = 0; i < capped.length; i++) {
+    const s = capped[i];
+    nodes.push({ id: "step-" + (i + 1), type: "step", title: clamp(s.name, 500), status: errs.get(s.id) === true ? "failed" : "completed", requires_evidence: false });
+  }
+  return nodes;
+}
+function authHeaders(env) {
+  if (env.ORGX_CLIENT_KEY) return { Authorization: "Bearer " + env.ORGX_CLIENT_KEY };
+  if (env.ORGX_API_KEY) {
+    const h = { Authorization: "Bearer " + env.ORGX_API_KEY };
+    if (env.ORGX_USER_ID) h["X-Orgx-User-Id"] = env.ORGX_USER_ID;
+    return h;
+  }
+  if (env.ORGX_SERVICE_KEY && env.ORGX_USER_ID) return { Authorization: "Bearer " + env.ORGX_SERVICE_KEY, "X-Orgx-User-Id": env.ORGX_USER_ID };
+  return null;
+}
+(async () => {
+  try {
+    const args = parseArgs(process.argv.slice(2));
+    const env = process.env;
+    if (!(truthy(args.enabled) || truthy(env.ORGX_EMIT_EXECUTION_GRAPH))) return;
+    const initiative = pick(env.ORGX_INITIATIVE_ID, args.initiative);
+    if (!initiative) return;
+    const auth = authHeaders(env);
+    if (!auth) return;
+    const raw = await readStdin();
+    let hook = {};
+    try { hook = raw && raw.trim() ? JSON.parse(raw) : {}; } catch (e) { hook = {}; }
+    const tp = pick(env.ORGX_TRANSCRIPT_PATH, hook.transcript_path);
+    let entries = [];
+    if (tp) { try { entries = jsonl(readFileSync(tp, "utf8")); } catch (e) { entries = []; } }
+    let max = parseInt(env.ORGX_EMIT_MAX_NODES || "", 10);
+    if (!Number.isFinite(max)) max = 40;
+    const nodes = derive(entries, max);
+    const sc = pick(args.source_client, env.ORGX_SOURCE_CLIENT, "claude-code");
+    const event = {
+      schema_version: "1.0.0",
+      initiative_id: initiative,
+      source_client: sc,
+      summary: clamp(env.ORGX_EMIT_SUMMARY, 2000) || (sc + " session: " + (nodes.length - 1) + " step(s)"),
+      nodes: nodes,
+      edges: [],
+      trust_events: [],
+      metadata: { emitter: "orgx-wizard-runtime-hook", via: "stop-hook" },
+    };
+    if (env.ORGX_RUN_ID) event.run_id = env.ORGX_RUN_ID;
+    else event.correlation_id = clamp(pick(hook.session_id, env.ORGX_CORRELATION_ID) || (sc + "-" + initiative), 120);
+    let base = env.ORGX_BASE_URL || "https://useorgx.com";
+    while (base.endsWith("/")) base = base.slice(0, -1);
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(), parseInt(env.ORGX_EMIT_TIMEOUT_MS || "", 10) || 4000);
+    try {
+      await fetch(base + "/api/client/live/execution-graph", {
+        method: "POST",
+        headers: Object.assign({ "Content-Type": "application/json" }, auth),
+        body: JSON.stringify(event),
+        signal: ctrl.signal,
+      });
+    } catch (e) {} finally { clearTimeout(timer); }
+  } catch (e) {}
+  process.exit(0);
+})();
+`;
+}
+function buildEmitHookCommand(params) {
+  return [
+    "node",
+    JSON.stringify(params.emitHookScriptPath),
+    "--enabled=true",
+    `--source_client=${params.sourceClient}`
+  ].join(" ");
+}
 function mergeCodexHooks(raw, paths) {
   const value = parseJsonObject(raw);
   const hooks = isRecord(value.hooks) ? value.hooks : {};
@@ -12940,6 +13098,20 @@ function mergeClaudeHooks(raw, paths) {
       rule.hooks = hooks;
       changed = true;
     }
+    if (event === "Stop") {
+      const emitCommand = buildEmitHookCommand({
+        emitHookScriptPath: paths.emitHookScriptPath,
+        sourceClient: "claude-code"
+      });
+      const emitAlready = hooks.some(
+        (entry) => isRecord(entry) && entry.type === "command" && typeof entry.command === "string" && entry.command.includes(EMIT_HOOK_MARKER)
+      );
+      if (!emitAlready) {
+        hooks.push({ type: "command", command: emitCommand });
+        rule.hooks = hooks;
+        changed = true;
+      }
+    }
     hooksRoot[event] = list;
   }
   value.hooks = hooksRoot;
@@ -12980,7 +13152,8 @@ function inspectRuntimeHooks(options = {}) {
     installed: {
       claudeCode: hasOrgxHook(claudeSettingsRaw),
       codex: hasOrgxHook(codexHooksRaw),
-      hookScript: existsSync9(paths.hookScriptPath)
+      hookScript: existsSync9(paths.hookScriptPath),
+      emitHookScript: existsSync9(paths.emitHookScriptPath)
     },
     codex: {
       configExists: Boolean(codexConfigRaw),
@@ -12999,7 +13172,8 @@ function installRuntimeHooks(targets, options = {}) {
     claudeCode: false,
     codex: false,
     codexConfig: false,
-    hookScript: false
+    hookScript: false,
+    emitHookScript: false
   };
   mkdirSync3(dirname4(paths.hookScriptPath), { recursive: true, mode: 448 });
   const scriptContent = buildRuntimeHookScriptContent();
@@ -13009,6 +13183,14 @@ function installRuntimeHooks(targets, options = {}) {
     writeTextFile(paths.hookScriptPath, scriptContent, { mode: 448 });
     changed.hookScript = true;
   }
+  mkdirSync3(dirname4(paths.emitHookScriptPath), { recursive: true, mode: 448 });
+  const emitScriptContent = buildExecutionGraphEmitScriptContent();
+  if (readTextIfExists(paths.emitHookScriptPath) !== emitScriptContent) {
+    const backup = backupExisting(paths.emitHookScriptPath, now);
+    if (backup) backups.push(backup);
+    writeTextFile(paths.emitHookScriptPath, emitScriptContent, { mode: 448 });
+    changed.emitHookScript = true;
+  }
   if (targets.includes("codex")) {
     const rawConfig = readTextIfExists(paths.codexConfigPath);
     const nextConfig = ensureCodexHooksFeature(rawConfig);
@@ -13136,6 +13318,15 @@ function printMutationResults(results) {
 }
 function printSurfaceSummary(results) {
   const summarized = summarizeMutationResults(results);
+  if (summarized.length === 0) {
+    console.log(
+      `  ${ICON.skip}  ${pc3.dim("No supported AI tools detected on this machine.")}`
+    );
+    console.log(
+      `  ${pc3.dim("\u2192")}  ${pc3.dim("Install Claude, Cursor, Codex, VS Code, Windsurf, or Zed, then re-run setup.")}`
+    );
+    return;
+  }
   const updated = summarized.filter((r) => r.state === "updated");
   if (updated.length === 0) {
     console.log(
@@ -13683,6 +13874,11 @@ async function runWorkGraphCommand(options, defaults = {}) {
   console.log(`  ${ICON.ok}  ${pc3.green("score         ")} ${pc3.dim(formatWorkGraphScoreLine(report.opportunity_score))}`);
   console.log(`  ${ICON.ok}  ${pc3.green("AQ            ")} ${pc3.dim(`${report.agentic_quotient.aq}/100 \xB7 Stack ${report.agentic_quotient.stack_score}/100 \xB7 Durable ${report.agentic_quotient.durability_score}/100 \xB7 Gap ${report.agentic_quotient.agentic_gap}`)}`);
   console.log(`  ${ICON.ok}  ${pc3.green("archetype     ")} ${pc3.dim(report.agentic_quotient.archetype.label)}`);
+  const topQuest = report.agentic_quotient.repair_quests[0];
+  if (topQuest) {
+    console.log(`  ${ICON.ok}  ${pc3.green("first lift    ")} ${pc3.bold(`+${topQuest.expected_aq_lift} AQ`)} ${pc3.dim(topQuest.title)}`);
+    console.log(`  ${ICON.skip}  ${pc3.bold("why now      ")} ${topQuest.reason}`);
+  }
   console.log(`  ${ICON.ok}  ${pc3.green("audit quality ")} ${pc3.dim(`${report.execution_quality.overall}/100 \xB7 coverage ${report.source_coverage.coverage_score ?? 0}/100`)}`);
   console.log(`  ${ICON.ok}  ${pc3.green("page quality  ")} ${pc3.dim(`${report.page_quality.overall}/100 \xB7 clarity ${report.page_quality.clarity}/100 \xB7 trust ${report.page_quality.trust}/100`)}`);
   console.log(`  ${ICON.ok}  ${pc3.green("impact        ")} ${pc3.dim(`${report.impact_projection.time_saved_hours_per_week}h/week \xB7 +${report.impact_projection.acceleration_percent}% acceleration \xB7 ~$${report.impact_projection.estimated_monthly_value_usd.toLocaleString("en-US")}/month`)}`);
@@ -14724,11 +14920,12 @@ function printDoctorReport(report, assessment) {
   console.log("");
   const configuredCount = report.surfaces.filter((s) => s.configured).length;
   if (assessment.issues.length === 0) {
-    console.log(`  ${ICON.ok}  ${pc3.green("All systems ready.")}`);
     if (!report.auth.configured) {
+      console.log(`  ${ICON.warn}  ${pc3.yellow("Not set up yet \u2014 pair this terminal to finish.")}`);
       console.log(`
-  ${pc3.dim("\u2192")}  ${pc3.cyan(`${getCmd()} auth login`)}  ${pc3.dim("to connect your account")}`);
+  ${pc3.dim("\u2192")}  ${pc3.cyan(`${getCmd()} setup`)}  ${pc3.dim("configures your AI tools and pairs your account")}`);
     } else {
+      console.log(`  ${ICON.ok}  ${pc3.green("All systems ready.")}`);
       console.log(`  ${pc3.dim("\u2192")}  ${pc3.dim(`OrgX is active across ${configuredCount} editor${configuredCount !== 1 ? "s" : ""}`)}`);
     }
   } else if (verification.transientTimeouts) {
@@ -14750,7 +14947,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.47" : void 0;
+  const pkgVersion = true ? "0.1.48" : void 0;
   program.version(pkgVersion ?? "unknown", "-V, --version");
   program.hook("preAction", (_thisCommand, actionCommand) => {
     if (Boolean(actionCommand.optsWithGlobals().json)) return;
@@ -15467,7 +15664,7 @@ async function main() {
     });
     await runAuditCommand(options);
   });
-  const workGraph = program.command("work-graph").description("Build a redacted OrgX Profile from AI-client session search, Slack, MCP, or manual context.");
+  const workGraph = program.command("work-graph").description("Run AQ from real AI-work receipts and surface the first repair that raises execution capacity.");
   workGraph.command("extraction-schema").description("Print the packaged AI-client audit skill used to search sessions, messages, tools, domains, and logs.").option("--output <path>", "write the schema prompt to a file").option("--json", "emit the protocol as JSON instead of Markdown").action(async (options) => {
     await safeTrackWizardTelemetry("work_graph_extraction_schema_started", {
       command: "work-graph extraction-schema",
@@ -15478,14 +15675,14 @@ async function main() {
   workGraph.command("runtime-event").description("Write a redacted Codex/Claude runtime packet into the Work Graph collector directory.").requiredOption("--source <source>", "agent source writing the packet: codex or claude").option("--summary <text>", "public-safe summary of the decision, artifact, blocker, outcome, or tool event").option("--message <text>", "alias for --summary").option("--event-kind <kind>", "event kind hint: decision, artifact, blocker, outcome, tool_call_error", "artifact").option("--role <role>", "source role: user, assistant, tool, or meta", "assistant").option("--tool-name <name>", "tool name when the packet represents a tool call").option("--cwd <path>", "workspace root that owns the collector directory").option("--output-dir <path>", "collector root relative to cwd", ".orgx/work-graph/runtime-events").option("--json", "emit a JSON summary").action((options) => {
     runWorkGraphRuntimeEventCommand(options);
   });
-  workGraph.command("preview").description("Preview the OrgX Profile evidence findings without writing to OrgX.").option("--input <path>", "source transcript or summary file; stdin is used when piped").option("--extraction <path>", "structured AI-client extraction JSON; repeat or comma-separate for multiple clients", collectPathOption, []).option("--from <sources>", "auto-import recent local AI sessions: claude, codex, opencode, goose, cursor, github, slack, or all").option("--session-limit <count>", "max recent sessions to import per selected source", "15").option("--session-days <days>", "lookback window for local AI-session imports", "60").option("--codex-sessions-dir <path>", "override Codex sessions directory for import").option("--claude-projects-dir <path>", "override Claude projects directory for import").option("--source-label <label>", "label for the imported manual 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 previews").option("--output-dir <path>", "directory for generated Work Graph JSON and Markdown", ".orgx/work-graph").option("--json", "emit a JSON command summary").action(async (options) => {
+  workGraph.command("preview").description("Preview AQ, evidence paths, and the first repair without writing to OrgX.").option("--input <path>", "source transcript or summary file; stdin is used when piped").option("--extraction <path>", "structured AI-client extraction JSON; repeat or comma-separate for multiple clients", collectPathOption, []).option("--from <sources>", "auto-import recent local AI sessions: claude, codex, opencode, goose, cursor, github, slack, or all").option("--session-limit <count>", "max recent sessions to import per selected source", "15").option("--session-days <days>", "lookback window for local AI-session imports", "60").option("--codex-sessions-dir <path>", "override Codex sessions directory for import").option("--claude-projects-dir <path>", "override Claude projects directory for import").option("--source-label <label>", "label for the imported manual 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 previews").option("--output-dir <path>", "directory for generated Work Graph JSON and Markdown", ".orgx/work-graph").option("--json", "emit a JSON command summary").action(async (options) => {
     await safeTrackWizardTelemetry("work_graph_preview_started", {
       command: "work-graph preview",
       from: options.from ?? "manual"
     });
     await runWorkGraphCommand(options);
   });
-  workGraph.command("profile").description("Build a local OrgX Profile with evidence findings, domain coverage, source confidence, and repair recommendations.").option("--input <path>", "source transcript or summary file; stdin is used when piped").option("--extraction <path>", "structured AI-client extraction JSON; repeat or comma-separate for multiple clients", collectPathOption, []).option("--from <sources>", "auto-import recent local AI sessions: claude, codex, opencode, goose, cursor, github, slack, or all").option("--session-limit <count>", "max recent sessions to import per selected source", "25").option("--session-days <days>", "lookback window for local AI-session imports", "60").option("--codex-sessions-dir <path>", "override Codex sessions directory for import").option("--claude-projects-dir <path>", "override Claude projects directory for import").option("--source-label <label>", "label for the imported manual 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 profiles").option("--output-dir <path>", "directory for generated Work Graph JSON and Markdown", ".orgx/work-graph").option("--publish", "publish the generated OrgX Profile to OrgX and return a shareable URL").option("--public-share", "create a public redacted /work-graph/<token> share when publishing").option("--attach-artifact", "attach the report as an OrgX artifact when an initiative/entity is provided").option("--attach-to-initiative <id>", "attach the report to an existing OrgX initiative").option("--entity-type <type>", "entity type for artifact attachment: project, initiative, milestone, task, decision").option("--entity-id <id>", "entity id for artifact attachment").option("--artifact-url <url>", "override the artifact URL stored in OrgX").option("--yes", "approve publish/write prompts in non-interactive mode").option("--json", "emit a JSON command summary").action(async (options) => {
+  workGraph.command("profile").description("Build an AQ profile from real receipts, publish it, and return the first executable repair.").option("--input <path>", "source transcript or summary file; stdin is used when piped").option("--extraction <path>", "structured AI-client extraction JSON; repeat or comma-separate for multiple clients", collectPathOption, []).option("--from <sources>", "auto-import recent local AI sessions: claude, codex, opencode, goose, cursor, github, slack, or all").option("--session-limit <count>", "max recent sessions to import per selected source", "25").option("--session-days <days>", "lookback window for local AI-session imports", "60").option("--codex-sessions-dir <path>", "override Codex sessions directory for import").option("--claude-projects-dir <path>", "override Claude projects directory for import").option("--source-label <label>", "label for the imported manual 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 profiles").option("--output-dir <path>", "directory for generated Work Graph JSON and Markdown", ".orgx/work-graph").option("--publish", "publish the generated OrgX Profile to OrgX and return a shareable URL").option("--public-share", "create a public redacted /work-graph/<token> share when publishing").option("--attach-artifact", "attach the report as an OrgX artifact when an initiative/entity is provided").option("--attach-to-initiative <id>", "attach the report to an existing OrgX initiative").option("--entity-type <type>", "entity type for artifact attachment: project, initiative, milestone, task, decision").option("--entity-id <id>", "entity id for artifact attachment").option("--artifact-url <url>", "override the artifact URL stored in OrgX").option("--yes", "approve publish/write prompts in non-interactive mode").option("--json", "emit a JSON command summary").action(async (options) => {
     await safeTrackWizardTelemetry("work_graph_profile_started", {
       command: "work-graph profile",
       from: options.from ?? "manual"