@useorgx/wizard 0.1.55 → 0.1.56

package/README.md

@@ -32,6 +32,7 @@ The wizard modifies local tool configuration only. Depending on the command, it
 - Every profile or preview writes both the full evidence report and a compact, machine-safe `work-graph-agent-brief-*.md` with provenance, the growth edge, and a ready prompt for the smallest verifiable repair.
 - `work-graph preview --from all` shows the same profile story 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.
+- `map [query...] --deep-search` runs the v1 Operating Map discovery flow over connected company signals and cited deep research, prints source health and low-confidence ProcessCards, and keeps ownership/timing/"done" confirmation human-gated. Add `--candidate <id-or-number> --yes` to explicitly propose one card as an OperatingProcess; the wizard never auto-confirms or activates inferred workflow ownership.
 - `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.
@@ -88,6 +89,7 @@ Set `ORGX_TELEMETRY_DISABLED=1` or `ORGX_TELEMETRY_ENABLED=0` to opt out.
 - 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.
+- The Operating Map loop is: `wizard map --deep-search "Map the intake, handoffs, systems of record, and completion criteria"`, inspect citations/source health/limitations, propose only a reviewed ProcessCard, confirm it in OrgX, then use the resulting OperatingProcess as the source for adoption and ValueCase projections. A cited report without a schema-valid candidate block remains observation-only.
 - `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

@@ -2,7 +2,7 @@
 
 // src/cli.ts
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="707a7fe5-404e-5aec-9c75-30f0f5d859d9")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="02842523-d681-5cea-96aa-0f0c896e9fb5")}catch(e){}}();
 import * as clack from "@clack/prompts";
 import { spawnSync as spawnSync5 } from "child_process";
 import { readFileSync as readFileSync8 } from "fs";
@@ -6211,7 +6211,7 @@ function initializeWizardSentry() {
   Sentry.init({
     dsn,
     environment: process.env.ORGX_SENTRY_ENVIRONMENT || "production",
-    release: "useorgx-wizard@0.1.55",
+    release: "useorgx-wizard@0.1.56",
     tracesSampleRate: sampleRate(process.env.ORGX_SENTRY_TRACES_SAMPLE_RATE),
     enableLogs: true,
     sendDefaultPii: false,
@@ -8592,11 +8592,138 @@ Rollback: ${plan.recommended_follow_up.rollback}`,
   );
 }
 
+// src/lib/operating-map.ts
+import { createHash as createHash6 } from "crypto";
+function parseResponseBody6(text2) {
+  if (!text2) return null;
+  try {
+    return JSON.parse(text2);
+  } catch {
+    return text2;
+  }
+}
+function formatHttpError5(status, body) {
+  if (typeof body === "string" && body.trim()) return `HTTP ${status}: ${body}`;
+  if (isRecord(body) && isRecord(body.error)) {
+    const code = typeof body.error.code === "string" ? body.error.code : "api_error";
+    const message = typeof body.error.message === "string" ? body.error.message : `HTTP ${status}`;
+    return `HTTP ${status} ${code}: ${message}`;
+  }
+  return `HTTP ${status}`;
+}
+function extractData(payload) {
+  return isRecord(payload) && "data" in payload ? payload.data : payload;
+}
+function parseDiscoveryResult(payload) {
+  const data = extractData(payload);
+  if (!isRecord(data) || !isRecord(data.run) || !Array.isArray(data.processCards)) {
+    throw new Error("OrgX returned an incomplete operating-map discovery payload.");
+  }
+  const run = data.run;
+  if (typeof run.id !== "string" || typeof run.mode !== "string" || typeof run.status !== "string") {
+    throw new Error("OrgX returned an invalid operating-map discovery run.");
+  }
+  return {
+    run: {
+      id: run.id,
+      mode: run.mode,
+      status: run.status,
+      query: typeof run.query === "string" ? run.query : null,
+      observationCount: typeof run.observationCount === "number" ? run.observationCount : 0,
+      candidateProcessCardCount: typeof run.candidateProcessCardCount === "number" ? run.candidateProcessCardCount : data.processCards.length,
+      citationCount: typeof run.citationCount === "number" ? run.citationCount : 0,
+      sourceHealth: Array.isArray(run.sourceHealth) ? run.sourceHealth : [],
+      limitations: Array.isArray(run.limitations) ? run.limitations.filter((item) => typeof item === "string") : []
+    },
+    observations: Array.isArray(data.observations) ? data.observations.filter(isRecord) : [],
+    processCards: data.processCards.filter(isRecord).map((card) => {
+      const ref = isRecord(card.processCandidateRef) ? card.processCandidateRef : {};
+      return {
+        processCandidateRef: {
+          id: typeof ref.id === "string" ? ref.id : "",
+          workspaceId: typeof ref.workspaceId === "string" ? ref.workspaceId : ""
+        },
+        displayName: typeof card.displayName === "string" ? card.displayName : "Unnamed workflow",
+        confidence: typeof card.confidence === "number" ? card.confidence : 0,
+        nextConfirmationQuestion: typeof card.nextConfirmationQuestion === "string" ? card.nextConfirmationQuestion : null,
+        candidateTrigger: isRecord(card.candidateTrigger) ? card.candidateTrigger : {},
+        handoffDelays: Array.isArray(card.handoffDelays) ? card.handoffDelays.filter(isRecord).map((handoff) => ({
+          from: typeof handoff.from === "string" ? handoff.from : "unknown",
+          to: typeof handoff.to === "string" ? handoff.to : "unknown",
+          delayMinutes: typeof handoff.delayMinutes === "number" ? handoff.delayMinutes : null
+        })) : [],
+        riskFlags: Array.isArray(card.riskFlags) ? card.riskFlags.filter((item) => typeof item === "string") : []
+      };
+    }),
+    confirmedProcessRefs: Array.isArray(data.confirmedProcessRefs) ? data.confirmedProcessRefs.filter(isRecord).flatMap(
+      (ref) => typeof ref.id === "string" && typeof ref.workspaceId === "string" ? [{ id: ref.id, workspaceId: ref.workspaceId }] : []
+    ) : []
+  };
+}
+async function requireOrgxAuth4(options = {}) {
+  const auth = await resolveOrgxAuth(options);
+  if (!auth) {
+    throw new Error("No OrgX API key configured. Run `wizard auth login` or set ORGX_API_KEY first.");
+  }
+  return auth;
+}
+function defaultOperatingMapIdempotencyKey(input) {
+  const digest = createHash6("sha256").update(JSON.stringify(input)).digest("hex").slice(0, 32);
+  return `wizard:operating-map:${input.workspaceId}:${digest}`;
+}
+async function startOperatingMapDiscovery(input, options = {}) {
+  const auth = await requireOrgxAuth4(options);
+  const response = await fetchWithRetry(buildOrgxApiUrl("/v1/discovery-runs", auth.baseUrl), {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${auth.apiKey}`,
+      "Content-Type": "application/json",
+      "Idempotency-Key": input.idempotencyKey
+    },
+    body: JSON.stringify({
+      workspace_id: input.workspaceId,
+      mode: input.mode ?? "bounded_sync",
+      query: input.query ?? null,
+      source_kinds: input.sourceKinds ?? []
+    })
+  });
+  const body = parseResponseBody6(await response.text());
+  if (!response.ok) {
+    throw new Error(`Unable to start the operating-map discovery run. ${formatHttpError5(response.status, body)}`);
+  }
+  const result = parseDiscoveryResult(body);
+  const meta = isRecord(body) && isRecord(body.meta) ? body.meta : {};
+  return { result, duplicate: meta.duplicate === true };
+}
+async function proposeOperatingProcessFromMap(input, options = {}) {
+  const auth = await requireOrgxAuth4(options);
+  const response = await fetchWithRetry(
+    buildOrgxApiUrl(`/v1/discovery-runs/${encodeURIComponent(input.discoveryRunId)}/propose`, auth.baseUrl),
+    {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${auth.apiKey}`,
+        "Content-Type": "application/json",
+        "Idempotency-Key": input.idempotencyKey
+      },
+      body: JSON.stringify({
+        workspace_id: input.workspaceId,
+        process_candidate_id: input.processCandidateId
+      })
+    }
+  );
+  const body = parseResponseBody6(await response.text());
+  if (!response.ok) {
+    throw new Error(`Unable to propose the OperatingProcess. ${formatHttpError5(response.status, body)}`);
+  }
+  return extractData(body);
+}
+
 // src/lib/work-graph.ts
-import { createHash as createHash7 } from "crypto";
+import { createHash as createHash8 } from "crypto";
 
 // src/lib/work-graph-investigation.ts
-import { createHash as createHash6 } from "crypto";
+import { createHash as createHash7 } from "crypto";
 var WORK_GRAPH_INVESTIGATION_SCHEMA_VERSION = "2.0.0";
 var WORK_GRAPH_INVESTIGATION_CLIENTS = [
   "claude_code",
@@ -8729,7 +8856,7 @@ var CAPABILITY_CEILINGS = {
   }
 };
 function hash3(value, length = 16) {
-  return createHash6("sha256").update(JSON.stringify(value)).digest("hex").slice(0, length);
+  return createHash7("sha256").update(JSON.stringify(value)).digest("hex").slice(0, length);
 }
 function clamp(value, min = 0, max = 1) {
   return Math.max(min, Math.min(max, value));
@@ -9831,7 +9958,7 @@ function clampScore2(value) {
   return Math.max(0, Math.min(100, Math.round(value)));
 }
 function hashJson(value) {
-  return createHash7("sha256").update(JSON.stringify(value)).digest("hex");
+  return createHash8("sha256").update(JSON.stringify(value)).digest("hex");
 }
 function normalizeFingerprintText(value) {
   return value.toLowerCase().replace(/https?:\/\/\S+/g, "url").replace(/[0-9a-f]{12,}/g, "hash").replace(/\b[0-9a-f]{8}-[0-9a-f-]{27,}\b/g, "uuid").replace(/\s+/g, " ").trim().slice(0, 600);
@@ -13043,14 +13170,14 @@ function renderAqAgentBrief(report, links = {}) {
 }
 
 // src/lib/work-graph-publish.ts
-import { createHash as createHash8, randomUUID as randomUUID2 } from "crypto";
+import { createHash as createHash9, randomUUID as randomUUID2 } from "crypto";
 import { gzipSync } from "zlib";
 var WORK_GRAPH_REPORT_GZIP_THRESHOLD_BYTES = 4e6;
 var WORK_GRAPH_REPORT_CHUNK_UPLOAD_THRESHOLD_BYTES = 5e5;
 var WORK_GRAPH_REPORT_CHUNK_CHARS = 3e4;
 var WORK_GRAPH_REPORT_CHUNK_UPLOAD_TIMEOUT_MS = 3e5;
 function hashText(value) {
-  return createHash8("sha256").update(value).digest("hex");
+  return createHash9("sha256").update(value).digest("hex");
 }
 function buildWorkGraphReportPostPayload(report, options = {}) {
   return {
@@ -13257,7 +13384,7 @@ async function publishWorkGraphEvents(fingerprint, patch, options = {}) {
 }
 
 // src/lib/work-graph-hook-events.ts
-import { createHash as createHash9 } from "crypto";
+import { createHash as createHash10 } from "crypto";
 import { existsSync as existsSync8, readFileSync as readFileSync6 } from "fs";
 var SOURCE_CLIENTS = [
   "codex",
@@ -13292,7 +13419,7 @@ function asStringArray(value) {
   return value.filter((item) => typeof item === "string" && item.trim().length > 0);
 }
 function stableHash(value) {
-  return createHash9("sha256").update(value).digest("hex").slice(0, 20);
+  return createHash10("sha256").update(value).digest("hex").slice(0, 20);
 }
 function normalizeSourceClient2(value) {
   const raw = asString2(value)?.toLowerCase();
@@ -15031,6 +15158,86 @@ async function runAuditCommand(options) {
     console.log(`  ${ICON.ok}  ${pc3.green("follow-up     ")} ${pc3.bold(followUp.title)} ${pc3.dim(followUp.id)}`);
   }
 }
+async function runOperatingMapCommand(queryParts, options) {
+  const auth = await resolveOrgxAuth();
+  if (!auth) {
+    throw new Error("Operating-map discovery requires OrgX auth. Run `wizard auth login` first.");
+  }
+  const workspace = options.workspaceId?.trim() ? { id: options.workspaceId.trim(), name: options.workspaceId.trim() } : await getCurrentWorkspace();
+  if (!workspace) {
+    throw new Error("No current OrgX workspace found. Run `wizard workspace create <name>` first.");
+  }
+  const query = queryParts.join(" ").trim() || null;
+  const mode = options.deepSearch ? "deep_search" : "bounded_sync";
+  const sourceKinds = (options.source ?? "").split(",").map((source) => source.trim()).filter(Boolean);
+  const idempotencyKey = options.idempotencyKey?.trim() || defaultOperatingMapIdempotencyKey({
+    workspaceId: workspace.id,
+    mode,
+    query,
+    sourceKinds
+  });
+  const spinner = createOrgxSpinner(mode === "deep_search" ? "Mapping workflows with cited deep search" : "Mapping observed workflows");
+  spinner.start();
+  const discovery = await startOperatingMapDiscovery({
+    workspaceId: workspace.id,
+    mode,
+    query,
+    sourceKinds,
+    idempotencyKey
+  });
+  spinner.succeed(discovery.duplicate ? "Replayed the existing operating-map discovery" : "Operating-map discovery complete");
+  const payload = {
+    workspaceId: workspace.id,
+    idempotencyKey,
+    duplicate: discovery.duplicate,
+    run: discovery.result.run,
+    processCards: discovery.result.processCards
+  };
+  if (options.json) {
+    console.log(JSON.stringify(payload, null, 2));
+  } else {
+    console.log(`  ${ICON.ok}  ${pc3.green("observations  ")} ${pc3.dim(String(discovery.result.run.observationCount))}`);
+    console.log(`  ${ICON.ok}  ${pc3.green("candidates    ")} ${pc3.dim(String(discovery.result.processCards.length))}`);
+    console.log(`  ${ICON.ok}  ${pc3.green("citations     ")} ${pc3.dim(String(discovery.result.run.citationCount))}`);
+    for (const [index, card] of discovery.result.processCards.entries()) {
+      console.log("");
+      console.log(`  ${pc3.bold(`${index + 1}. ${card.displayName}`)} ${pc3.dim(`${Math.round(card.confidence * 100)}% confidence \xB7 ${card.processCandidateRef.id}`)}`);
+      if (card.nextConfirmationQuestion) console.log(`     ${pc3.yellow("confirm:")} ${card.nextConfirmationQuestion}`);
+      if (card.riskFlags.length > 0) console.log(`     ${pc3.yellow("limits:")} ${card.riskFlags.join("; ")}`);
+    }
+    if (discovery.result.run.limitations.length > 0) {
+      console.log("");
+      console.log(`  ${pc3.yellow("limitations:")} ${discovery.result.run.limitations.join("; ")}`);
+    }
+  }
+  const candidate = options.candidate?.trim();
+  if (!candidate) return;
+  const selected = /^\d+$/.test(candidate) ? discovery.result.processCards[Number(candidate) - 1] : discovery.result.processCards.find((card) => card.processCandidateRef.id === candidate);
+  if (!selected?.processCandidateRef.id) {
+    throw new Error(`Process candidate ${candidate} was not found in discovery run ${discovery.result.run.id}.`);
+  }
+  const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY);
+  if (!options.yes) {
+    if (!interactive) throw new Error("Proposing an OperatingProcess requires --yes in non-interactive mode.");
+    const confirmed = await clack.confirm({
+      message: `Propose \u201C${selected.displayName}\u201D as an OperatingProcess (still requires human confirmation)?`,
+      initialValue: false
+    });
+    if (clack.isCancel(confirmed) || !confirmed) return;
+  }
+  const proposal = await proposeOperatingProcessFromMap({
+    workspaceId: workspace.id,
+    discoveryRunId: discovery.result.run.id,
+    processCandidateId: selected.processCandidateRef.id,
+    idempotencyKey: `wizard:operating-process:${discovery.result.run.id}:${selected.processCandidateRef.id}`
+  });
+  if (options.json) {
+    console.log(JSON.stringify({ ...payload, proposal }, null, 2));
+  } else {
+    console.log(`  ${ICON.ok}  ${pc3.green("proposal      ")} ${pc3.dim(selected.displayName)}`);
+    console.log(`  ${pc3.dim("Next step     ")} Review and confirm the OperatingProcess in OrgX; the wizard never auto-activates inferred workflow ownership.`);
+  }
+}
 function runWorkGraphExtractionSchemaCommand(options) {
   const protocol = buildWorkGraphExtractionProtocol();
   const outputPath = options.output?.trim() ? resolve3(options.output.trim()) : "";
@@ -16319,7 +16526,7 @@ async function main() {
   initializeWizardSentry();
   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.55" : void 0;
+  const pkgVersion = true ? "0.1.56" : void 0;
   program.version(pkgVersion ?? "unknown", "-V, --version");
   program.hook("preAction", (_thisCommand, actionCommand) => {
     if (Boolean(actionCommand.optsWithGlobals().json)) return;
@@ -17040,6 +17247,15 @@ async function main() {
     });
     await runAuditCommand(options);
   });
+  program.command("map").alias("discovery").description("Map observed company workflows into evidence-gated OperatingProcess candidates.").argument("[query...]", "workflow, handoff, or system-of-record question for discovery/deep search").option("--deep-search", "query cited external research in addition to connected repository signals").option("--source <kinds>", "comma-separated source kinds to report and constrain (for example github,notion,slack)").option("--workspace-id <id>", "workspace id override; defaults to the current OrgX workspace").option("--candidate <id-or-number>", "propose one returned ProcessCard by id or 1-based display number").option("--idempotency-key <key>", "stable retry key; defaults to a hash of workspace, mode, query, and sources").option("--yes", "approve the explicit proposal in non-interactive mode").option("--json", "emit machine-readable discovery/proposal output").action(async (queryParts, options) => {
+    await safeTrackWizardTelemetry("operating_map_started", {
+      command: "map",
+      deep_search: Boolean(options.deepSearch),
+      has_candidate: Boolean(options.candidate),
+      json: Boolean(options.json)
+    });
+    await runOperatingMapCommand(queryParts, options);
+  });
   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", {
@@ -17348,4 +17564,4 @@ main().catch(async (error) => {
   process.exitCode = 1;
 });
 //# sourceMappingURL=cli.js.map
-//# debugId=707a7fe5-404e-5aec-9c75-30f0f5d859d9
+//# debugId=02842523-d681-5cea-96aa-0f0c896e9fb5