@useorgx/wizard 0.1.30 → 0.1.31

package/dist/cli.js

@@ -6234,6 +6234,19 @@ var ORGX_TOOL_SIGNAL_PATTERN = /\b(?:mcp__orgx__|orgx_emit_activity|orgx_apply_c
 var INSTRUCTION_BOILERPLATE_PATTERN = /^(?:#{1,6}\s*)?(?:agents\.md|instructions?|codex guardrails|precedence|read before you write|use exactly what was specified|don'?t confuse technologies|repo \+ scope hygiene|initiative \/ mcp discipline|ui quality bar|verification standards|secrets \+ safety|patch\/editing rules|commit \/ pr \/ merge protocol|output style|mcp integration|agent domains|skills|conventions)\b/i;
 var IMPERATIVE_BOILERPLATE_PATTERN = /^[-*]\s+(?:if the user|when the user|if mcp|when agents|never|always|do not|don'?t|default to|treat|produce|pick|verify|avoid|match|use exactly|keep system boundaries|quote bracketed|for orgx|when capture tooling|if no meaningful|do \*\*not\*\*)\b/i;
 var CODE_OR_DOC_NOISE_PATTERN = /^(?:[-*]\s*)?(?:https?:\/\/|\/|\.{0,2}\/|[A-Za-z]:\/|`{1,3}|"{1,2}[A-Za-z0-9:_-]+":|\d+\s*$|\d+\t|import\s|export\s|const\s|let\s|var\s|function\s|type\s|interface\s|CREATE\s+TABLE|ALTER\s+TABLE|SELECT\s+|INSERT\s+|UPDATE\s+|DELETE\s+)/i;
+var EMPTY_AUDIT_LABEL_PATTERN = /^(?:[-*]\s*)?(?:decision|artifact|receipt|proof|commitment|next action|follow[- ]?up|outcome|result|impact|roi|economics|open loop|gap|blocker|risk|owner|dri|rollback|quality score)\s*:\s*[\[{(;,]*$/i;
+var TYPE_SIGNATURE_NOISE_PATTERN = /^(?:[-*]\s*)?(?:decision|artifact|receipt|proof|commitment|next action|follow[- ]?up|outcome|result|impact|roi|economics|open loop|gap|blocker|risk|owner|dri|rollback|quality score)\s*:\s*[A-Za-z_$][\w$]*(?:<[^>]+>)?[\s,;)]*$/i;
+var TOOL_CATALOG_NOISE_PATTERN = /^(?:[-*]\s*)?(?:[a-z][\w.:-]*\s*\([^)]+\),?\s*){2,}$/i;
+var BARE_TOOL_SIGNAL_PATTERN = /^(?:\d+\.\s*|[-*]\s*)?(?:mcp__orgx__[\w-]*|orgx_emit_activity|orgx_apply_changeset|complete_with_proof|scaffold_initiative|get_task_with_context|ship_batch|record_outcome|orgx_free_audit)\s*$/i;
+var TOOL_QUESTION_NOISE_PATTERN = /^(?:\d+\.\s*)?\*\*[^*]+\*\*.*\?\s*(?:\([^)]*\b(?:mcp|scaffold_initiative|start_plan_session)\b[^)]*\)\.?)?$/i;
+var SOURCE_REFERENCE_NOISE_PATTERN = /(?:^|\s)(?:\.{0,2}\/)?(?:orgx|src|lib|workers|public|scripts|tests|apps|packages)\/[\w./-]+\.(?:ts|tsx|js|jsx|json|md|txt|sql|py)(?::\d+)?\b/i;
+var FILE_REFERENCE_NOISE_PATTERN = /\b[\w.-]+\.(?:ts|tsx|js|jsx|json|md|txt|sql|py)(?::\d+(?:[–-]\d+)?)?\b/i;
+var LOCAL_ASSET_REFERENCE_PATTERN = /(?:<BlogImage\b|source:\s*\/Users\/|\/blog\/[\w./-]+\.(?:png|jpg|jpeg|webp|gif))/i;
+var LINE_NUMBER_SOURCE_NOISE_PATTERN = /^\d+(?::|\s+)\s*/i;
+var TOOL_WORKFLOW_NOISE_PATTERN = /(?:→|->).*\b(?:scaffold_initiative|spawn_agent_task|record_outcome|submit_learning|get_outcome_attribution|mcp__orgx__)\b/i;
+var TOOL_FAILURE_PATTERN = /^(?:\d+\.\s*)?(?:mcp__orgx__[\w-]*|orgx_emit_activity|orgx_apply_changeset|complete_with_proof|scaffold_initiative|get_task_with_context|ship_batch|record_outcome|orgx_free_audit)\b.*\b(?:rejected|requires|failed|fails|error|invalid|unavailable|timeout|timed out|not\s+(?:called|dispatched|wired|created|available)|missing|broken)\b/i;
+var RUNTIME_FAILURE_PATTERN = /\b(?:mcp__orgx__[\w-]*|orgx_emit_activity|orgx_apply_changeset|complete_with_proof|scaffold_initiative|get_task_with_context|ship_batch|record_outcome|submit_learning|spawn_agent_task|agent run)\b.*\b(?:rejected|requires|failed|fails|error|invalid|unavailable|timeout|timed out|never|no\s+\w+|not\s+(?:called|dispatched|wired|created|available|append)|missing|broken|only\s+in\s+agent\s+skill\s+prompts)\b/i;
+var PROCESS_NARRATION_NOISE_PATTERN = /^(?:now i\b|let me\b|i (?:have|need|will|can)\b|i['’]ll\b|i['’]m\b|so\b.*\b(?:confirm|check|verify|fetches)\b)/i;
 function parseAiSessionSources(value) {
   if (!value?.trim()) return [];
   const requested = value.split(",").map((item) => item.trim().toLowerCase()).filter(Boolean);
@@ -6266,6 +6279,75 @@ function asText(value) {
   if (isRecord(value) && typeof value.text === "string") return value.text;
   return "";
 }
+function stringFromRecord(record, key) {
+  const value = record[key];
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function numberFromRecord(record, key) {
+  const value = record[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function normalizeJsonAuditLine(line) {
+  if (!line.startsWith("{")) return null;
+  const parsed = parseJsonLine(line);
+  if (!isRecord(parsed)) return null;
+  const summary = stringFromRecord(parsed, "summary");
+  const stats = isRecord(parsed.summary_stats) ? parsed.summary_stats : void 0;
+  const requestedCount = stats ? numberFromRecord(stats, "requested_count") : void 0;
+  const createdCount = stats ? numberFromRecord(stats, "created_count") : void 0;
+  const failedCount = stats ? numberFromRecord(stats, "failed_count") : void 0;
+  const hierarchy = isRecord(parsed.hierarchy) ? parsed.hierarchy : void 0;
+  const initiative = hierarchy && isRecord(hierarchy.initiative) ? hierarchy.initiative : void 0;
+  const initiativeTitle = initiative ? stringFromRecord(initiative, "title") ?? stringFromRecord(initiative, "name") : void 0;
+  const initiativeError = initiative ? stringFromRecord(initiative, "error") : void 0;
+  if (summary && requestedCount !== void 0 && createdCount !== void 0 && failedCount !== void 0 && /\bcreated\b/i.test(summary)) {
+    const titleSuffix = initiativeTitle ? ` for ${initiativeTitle}` : "";
+    const errorSuffix = initiativeError ? `; ${initiativeError.replace(/\.+$/, "")}` : "";
+    if (failedCount > 0) {
+      return `Blocker: OrgX scaffold created ${createdCount}/${requestedCount} entities${titleSuffix}${errorSuffix}.`;
+    }
+    return `Artifact: OrgX scaffold created ${createdCount}/${requestedCount} entities${titleSuffix}.`;
+  }
+  return null;
+}
+function normalizeAuditRelevantLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed) return null;
+  const jsonLine = normalizeJsonAuditLine(trimmed);
+  if (jsonLine) return jsonLine;
+  if (trimmed.startsWith("{") || trimmed.startsWith("[")) return null;
+  if (SOURCE_REFERENCE_NOISE_PATTERN.test(trimmed)) return null;
+  if (FILE_REFERENCE_NOISE_PATTERN.test(trimmed)) return null;
+  if (LOCAL_ASSET_REFERENCE_PATTERN.test(trimmed)) return null;
+  if (LINE_NUMBER_SOURCE_NOISE_PATTERN.test(trimmed)) return null;
+  if (/^audit\s+\/Users\//i.test(trimmed)) return null;
+  if (/^#{1,6}\s/.test(trimmed)) return null;
+  if (PROCESS_NARRATION_NOISE_PATTERN.test(trimmed)) return null;
+  if (/^(?:\d+\.\s*)?(?:[-*]\s*)?(?:\*\*)?\b(?:integration gaps|gaps between)\b/i.test(trimmed)) return null;
+  if (/^\s*[-*]\s+the `?orgx`? mcp tools listed/i.test(trimmed)) return null;
+  if (TOOL_WORKFLOW_NOISE_PATTERN.test(trimmed)) return null;
+  const toolFailure = trimmed.match(TOOL_FAILURE_PATTERN);
+  if (toolFailure) {
+    return `Blocker: ${trimmed.replace(/^\d+\.\s*/, "")}`;
+  }
+  if (RUNTIME_FAILURE_PATTERN.test(trimmed)) {
+    const label = /^no programmatic\b/i.test(trimmed) ? "Gap" : "Blocker";
+    return `${label}: ${trimmed.replace(/^\d+\.\s*/, "")}`;
+  }
+  if (!AUDIT_RELEVANT_LINE_PATTERN.test(trimmed)) return null;
+  if (!STRONG_AUDIT_LINE_PATTERN.test(trimmed) && !ORGX_TOOL_SIGNAL_PATTERN.test(trimmed)) return null;
+  if (INSTRUCTION_BOILERPLATE_PATTERN.test(trimmed)) return null;
+  if (IMPERATIVE_BOILERPLATE_PATTERN.test(trimmed)) return null;
+  if (CODE_OR_DOC_NOISE_PATTERN.test(trimmed)) return null;
+  if (EMPTY_AUDIT_LABEL_PATTERN.test(trimmed)) return null;
+  if (TYPE_SIGNATURE_NOISE_PATTERN.test(trimmed)) return null;
+  if (TOOL_CATALOG_NOISE_PATTERN.test(trimmed)) return null;
+  if ((trimmed.match(/\b[a-z][\w.:-]*\s*\([^)]+\)/g) ?? []).length >= 2) return null;
+  if (BARE_TOOL_SIGNAL_PATTERN.test(trimmed)) return null;
+  if (TOOL_QUESTION_NOISE_PATTERN.test(trimmed)) return null;
+  if (/^[-*]\s+all agents\b/i.test(trimmed)) return null;
+  return trimmed;
+}
 function extractCodexMessageText(record) {
   if (!isRecord(record) || record.type !== "response_item" || !isRecord(record.payload)) {
     return "";
@@ -6289,9 +6371,7 @@ function extractClaudeMessageText(record) {
   return text2;
 }
 function keepAuditRelevantLines(text2) {
-  return text2.split(/\r?\n/).map((line) => line.trim()).filter(
-    (line) => line.length > 0 && AUDIT_RELEVANT_LINE_PATTERN.test(line) && (STRONG_AUDIT_LINE_PATTERN.test(line) || ORGX_TOOL_SIGNAL_PATTERN.test(line)) && !INSTRUCTION_BOILERPLATE_PATTERN.test(line) && !IMPERATIVE_BOILERPLATE_PATTERN.test(line) && !CODE_OR_DOC_NOISE_PATTERN.test(line)
-  );
+  return text2.split(/\r?\n/).map((line) => normalizeAuditRelevantLine(line)).filter((line) => Boolean(line));
 }
 function collectJsonlFiles(root, source) {
   if (!existsSync5(root)) return [];
@@ -6900,6 +6980,19 @@ Rollback: ${plan.recommended_follow_up.rollback}`,
 import { createHash as createHash4 } from "crypto";
 var WORK_GRAPH_SCHEMA_VERSION = "2026-05-07";
 var WORK_GRAPH_FINGERPRINT_VERSION = "wgf_v1";
+var WORK_GRAPH_EXTRACTION_SCHEMA_VERSION = "2026-05-07.ai-client-search.v1";
+var WORK_GRAPH_FINDING_TYPES = [
+  "action",
+  "decision",
+  "artifact",
+  "blocker",
+  "person",
+  "business",
+  "product_surface",
+  "goal",
+  "initiative_candidate",
+  "missed_orchestration_opportunity"
+];
 function clampScore2(value) {
   return Math.max(0, Math.min(100, Math.round(value)));
 }
@@ -6934,11 +7027,175 @@ function sourceClientForImport(source) {
   if (raw.includes("manual") || raw.includes("wizard-audit-input")) return "manual";
   return "unknown";
 }
+function normalizeSourceClient(value) {
+  if (typeof value !== "string") return "unknown";
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "codex" || normalized === "claude" || normalized === "claude-code" || normalized === "cursor" || normalized === "openclaw" || normalized === "slack" || normalized === "mcp" || normalized === "github" || normalized === "linear" || normalized === "manual" || normalized === "wizard" || normalized === "api") {
+    return normalized;
+  }
+  if (normalized.includes("claude")) return "claude";
+  if (normalized.includes("codex")) return "codex";
+  if (normalized.includes("cursor")) return "cursor";
+  if (normalized.includes("slack")) return "slack";
+  if (normalized.includes("github")) return "github";
+  if (normalized.includes("linear")) return "linear";
+  if (normalized.includes("mcp")) return "mcp";
+  return "unknown";
+}
+function normalizeFindingType(value) {
+  if (typeof value !== "string") return null;
+  const normalized = value.trim().toLowerCase();
+  return WORK_GRAPH_FINDING_TYPES.includes(normalized) ? normalized : null;
+}
+function normalizeConfidence(value, fallback = 0.72) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return fallback;
+  return Math.max(0.1, Math.min(0.99, Number(value.toFixed(2))));
+}
 function titleFromText(text2, fallback) {
   const normalized = text2.replace(/^\s*(decision|artifact|commitment|next action|follow[- ]?up|outcome|roi|economics|open loop|gap|blocker|risk|goal)\s*:\s*/i, "").trim();
   const firstSentence = normalized.split(/[.!?]\s/)[0]?.trim() || normalized;
   return (firstSentence || fallback).slice(0, 160);
 }
+function normalizeClientExtractionId(extraction, index) {
+  return extraction.extraction_id?.trim() || `${extraction.source_client || "unknown"}:client-extraction:${index + 1}`;
+}
+function buildWorkGraphExtractionProtocol() {
+  const schema = {
+    schema_version: WORK_GRAPH_EXTRACTION_SCHEMA_VERSION,
+    mode: "ai_client_session_search",
+    objective: "Search the AI client's own sessions, logs, tool calls, and local transcript index to extract durable work-graph evidence for OrgX.",
+    privacy_contract: [
+      "Do not return raw transcripts.",
+      "Return short redacted verbatim snippets only when they materially support a finding.",
+      "Prefer evidence refs, session ids, timestamps, source ids, and hashes over full content.",
+      "Mark private customer/person data as private or redacted.",
+      "Do not invent people, decisions, artifacts, or outcomes that are not supported by a source event."
+    ],
+    source_search_strategy: [
+      {
+        id: "decisions",
+        lens: "Decision trails",
+        query: "Find choices, tradeoffs, approvals, rejected options, contradictions, architecture calls, product calls, and decisions that were restated later.",
+        return_when: "A choice shaped future work, blocked work, or should become durable organizational memory."
+      },
+      {
+        id: "artifacts",
+        lens: "Artifact trails",
+        query: "Find created or modified artifacts: PRs, files, docs, designs, prompts, plans, reports, screenshots, deployed routes, tests, and verification receipts.",
+        return_when: "The artifact has a source event, proof reference, downstream use, owner, or missing verification."
+      },
+      {
+        id: "blockers",
+        lens: "Blocker trails",
+        query: "Find failed tool calls, timeouts, rejected validators, missing auth, missing source coverage, repeated unresolved questions, stalled owners, and external blockers.",
+        return_when: "The blocker explains why work did not become durable, verified, assigned, or shipped."
+      },
+      {
+        id: "people_businesses",
+        lens: "People and business trails",
+        query: "Find users, customers, buyers, stakeholders, reviewers, teams, businesses, accounts, and market signals connected to work or decisions.",
+        return_when: "A person or business changes priority, ownership, revenue potential, customer pain, or follow-up urgency."
+      },
+      {
+        id: "product_surfaces",
+        lens: "Product surface trails",
+        query: "Find surfaces such as live rooms, command center, widgets, plugins, wizard flows, public pages, APIs, MCP tools, Slack/GitHub/Linear integrations, and signup/claim flows.",
+        return_when: "A surface was changed, verified, blocked, requested, or connected to a goal or artifact."
+      },
+      {
+        id: "agents_tools_sources",
+        lens: "Agent/tool/source trails",
+        query: "Find agent runs, subagents, MCP calls, hook lifecycle events, tool availability, tool misses, source coverage, and runtime writeback behavior.",
+        return_when: "The event proves whether OrgX was called, skipped, unavailable, or only mentioned in instructions."
+      },
+      {
+        id: "outcomes_roi",
+        lens: "Outcome and ROI trails",
+        query: "Find shipped/completed work, test/browser/deploy verification, outcomes, time saved, cost, revenue, customer impact, attribution, and expected lift.",
+        return_when: "The outcome can be tied to evidence and a prior decision, artifact, blocker, or source."
+      },
+      {
+        id: "recurrence",
+        lens: "Recurring patterns",
+        query: "Find repeated shapes across sessions: trapped decisions, orphaned artifacts, missing owner, repeated work, source gaps, tooling mismatch, unverified outcomes, handoff friction, and unclaimed business signals.",
+        return_when: "The same pattern appears across multiple sessions, days, tools, actors, or product surfaces."
+      }
+    ],
+    required_output: {
+      schema_version: WORK_GRAPH_EXTRACTION_SCHEMA_VERSION,
+      extraction_id: "stable id for this extraction run",
+      source_client: "codex | claude | claude-code | cursor | openclaw | slack | mcp | github | linear | manual | api | unknown",
+      source_label: "human-readable source label",
+      searched_sources: ["session/log/source group names searched"],
+      search_queries: [
+        {
+          id: "decisions",
+          lens: "Decision trails",
+          query: "query actually used",
+          result_count: 0
+        }
+      ],
+      extraction_quality: {
+        confidence: 0,
+        searched_session_count: 0,
+        skipped_session_count: 0,
+        notes: ["limits, permissions, or gaps"]
+      },
+      findings: [
+        {
+          type: "decision | artifact | blocker | person | business | product_surface | goal | action | initiative_candidate | missed_orchestration_opportunity",
+          title: "short durable title, not a raw line",
+          summary: "one sentence explaining why this matters",
+          source_id: "session/tool/source id",
+          source_label: "source label",
+          evidence_ref: "stable evidence pointer",
+          confidence: 0,
+          occurred_at: "ISO timestamp if known",
+          actor_id: "redacted actor id if known",
+          redacted_verbatim: "short supporting excerpt only",
+          privacy_state: "public | redacted | private",
+          metadata: {
+            related_entity_names: [],
+            related_source_ids: [],
+            recurrence_count: 0,
+            state: "observed | inferred | verified | blocked | missing_evidence"
+          }
+        }
+      ]
+    },
+    quality_bar: [
+      "Search broadly before summarizing; do not stop at the newest session if older sessions contain recurrence.",
+      "Every finding must include a source id or evidence ref.",
+      "A trail starts only from evidence-bearing work signals, not empty labels, code type signatures, tool catalogs, or guardrail text.",
+      "Prefer fewer, higher-confidence findings over many shallow lines.",
+      "Include negative evidence when OrgX/MCP was available but not called.",
+      "Separate actual tool calls from textual mentions of tool names.",
+      "Mark confidence below 0.6 when the finding is inferred from weak or single-source evidence.",
+      "Do not emit raw JSON tool payloads; summarize the tool result into a blocker/artifact/outcome finding."
+    ],
+    reject_as_noise: [
+      "AGENTS.md or system guardrail instructions.",
+      "Source-code paths and line-number references unless the code change itself is the artifact.",
+      "Bare labels like Decision:, Receipt:, Impact:, or proof: {.",
+      "Type signatures such as outcome: string; or decision: ReviewableDecision;",
+      "Tool catalogs and lists of available MCP tools.",
+      "Planning narration like let me check, now I will inspect, or I need to verify.",
+      "Generic MCP/AI commentary without a concrete work event."
+    ]
+  };
+  const prompt = [
+    "You are generating an OrgX Work Graph extraction from your own AI-client session/search logs.",
+    "Search across available local sessions, transcripts, tool-call logs, hook events, and source indexes using every lens in the schema.",
+    "Return JSON only. Match the required_output shape exactly. Do not return raw transcripts.",
+    "The output will initiate Work Graph Trails, so every finding must be evidence-bearing and useful enough for a human to inspect."
+  ].join(" ");
+  return {
+    schema_version: WORK_GRAPH_EXTRACTION_SCHEMA_VERSION,
+    mode: "ai_client_session_search",
+    prompt,
+    schema
+  };
+}
 function findingTypeForItem(item) {
   switch (item.type) {
     case "decision":
@@ -6961,8 +7218,19 @@ function evidenceRefFor(sourceId, index) {
 function includesAny2(text2, patterns) {
   return patterns.some((pattern) => pattern.test(text2));
 }
-function buildCoverage(imports, connectedSources, missingSources) {
-  const allText = imports.map((source) => source.text).join("\n").toLowerCase();
+function buildCoverage(imports, connectedSources, missingSources, clientExtractions = []) {
+  const extractionText = clientExtractions.flatMap((extraction) => [
+    extraction.source_client,
+    extraction.source_label ?? "",
+    ...extraction.searched_sources ?? [],
+    ...(extraction.findings ?? []).flatMap((finding) => [
+      finding.title,
+      finding.summary,
+      finding.redacted_verbatim ?? ""
+    ])
+  ]).join("\n");
+  const allText = `${imports.map((source) => source.text).join("\n")}
+${extractionText}`.toLowerCase();
   const orgxObserved = /\borgx\b|useorgx|mcp__orgx__|orgx_/i.test(allText);
   const mcpObserved = /\bmcp\b|mcp__|tool call|tools\/call|call_tool|orgx_emit_activity/i.test(allText);
   const orgxMcpCalled = /mcp__orgx__|orgx_emit_activity|orgx_apply_changeset|complete_with_proof|scaffold_initiative/i.test(allText);
@@ -6976,6 +7244,75 @@ function buildCoverage(imports, connectedSources, missingSources) {
     skillOnlySignal
   };
 }
+function summarizeClientExtractions(clientExtractions) {
+  return clientExtractions.map((extraction, index) => {
+    const extractionId = normalizeClientExtractionId(extraction, index);
+    return {
+      extraction_id: extractionId,
+      source_client: normalizeSourceClient(extraction.source_client),
+      source_label: extraction.source_label?.trim() || `${extraction.source_client || "Unknown"} AI-client extraction`,
+      searched_source_count: extraction.searched_sources?.length ?? 0,
+      query_count: extraction.search_queries?.length ?? 0,
+      finding_count: extraction.findings.length,
+      confidence: normalizeConfidence(extraction.extraction_quality?.confidence, 0.74)
+    };
+  });
+}
+function buildClientExtractionEvents(clientExtractions) {
+  return summarizeClientExtractions(clientExtractions).map((summary) => ({
+    schema_version: WORK_GRAPH_SCHEMA_VERSION,
+    source_client: summary.source_client,
+    source_id: summary.extraction_id,
+    source_label: summary.source_label,
+    event_type: "client_extraction",
+    text: [
+      `${summary.finding_count} structured findings extracted by ${summary.source_client}.`,
+      `${summary.query_count} search queries across ${summary.searched_source_count} searched source groups.`,
+      `Extraction confidence: ${summary.confidence}.`
+    ].join(" "),
+    evidence_ref: `${summary.extraction_id}:summary`,
+    metadata: {
+      finding_count: summary.finding_count,
+      query_count: summary.query_count,
+      searched_source_count: summary.searched_source_count,
+      raw_transcript_sent: false
+    }
+  }));
+}
+function buildClientExtractionFindings(clientExtractions) {
+  const findings = [];
+  clientExtractions.forEach((extraction, extractionIndex) => {
+    const extractionId = normalizeClientExtractionId(extraction, extractionIndex);
+    const sourceClient = normalizeSourceClient(extraction.source_client);
+    const sourceLabel = extraction.source_label?.trim() || `${sourceClient} AI-client extraction`;
+    extraction.findings.forEach((finding, findingIndex) => {
+      const type = normalizeFindingType(finding.type);
+      const title = finding.title?.trim();
+      const summary = finding.summary?.trim();
+      if (!type || !title || !summary) return;
+      findings.push({
+        type,
+        title: title.slice(0, 180),
+        summary,
+        source_client: sourceClient,
+        source_id: finding.source_id?.trim() || extractionId,
+        evidence_ref: finding.evidence_ref?.trim() || `${extractionId}:F${findingIndex + 1}`,
+        confidence: normalizeConfidence(finding.confidence, normalizeConfidence(extraction.extraction_quality?.confidence, 0.76)),
+        metadata: {
+          source_label: finding.source_label?.trim() || sourceLabel,
+          extraction_id: extractionId,
+          schema_version: extraction.schema_version ?? null,
+          occurred_at: finding.occurred_at ?? null,
+          actor_id: finding.actor_id ?? null,
+          redacted_verbatim: finding.redacted_verbatim ?? null,
+          privacy_state: finding.privacy_state ?? "redacted",
+          ...finding.metadata ?? {}
+        }
+      });
+    });
+  });
+  return findings;
+}
 function buildDerivedFindings(imports) {
   const findings = [];
   let derivedIndex = 0;
@@ -7746,15 +8083,20 @@ function buildWorkGraphFingerprint(input) {
   };
 }
 function buildSessionReconciliationReport(input) {
-  if (input.imports.length === 0) {
-    throw new Error("At least one source import is required to build a Work Graph report.");
+  const clientExtractions = input.clientExtractions ?? [];
+  if (input.imports.length === 0 && clientExtractions.length === 0) {
+    throw new Error("At least one source import or AI-client extraction is required to build a Work Graph report.");
   }
   const generatedAt = input.generatedAt ?? (/* @__PURE__ */ new Date()).toISOString();
-  const connectedSources = input.connectedSources ?? input.imports.map((source) => source.sourceLabel);
+  const clientExtractionSummaries = summarizeClientExtractions(clientExtractions);
+  const connectedSources = sortedUnique([
+    ...input.connectedSources ?? input.imports.map((source) => source.sourceLabel),
+    ...clientExtractionSummaries.map((summary) => summary.source_label)
+  ]);
   const missingSources = input.missingSources ?? [];
-  const coverage = buildCoverage(input.imports, connectedSources, missingSources);
-  const events = buildWorkGraphEvents(input.imports);
-  const findings = buildWorkGraphFindings(input.imports);
+  const coverage = buildCoverage(input.imports, connectedSources, missingSources, clientExtractions);
+  const events = [...buildWorkGraphEvents(input.imports), ...buildClientExtractionEvents(clientExtractions)];
+  const findings = [...buildWorkGraphFindings(input.imports), ...buildClientExtractionFindings(clientExtractions)];
   const missed = buildMissedOpportunities(coverage, findings);
   const allFindings = [...findings, ...missed];
   const trails = buildWorkGraphTrails(allFindings, generatedAt);
@@ -7785,6 +8127,10 @@ function buildSessionReconciliationReport(input) {
   });
   const reportSeed = {
     generatedAt,
+    clientExtractions: clientExtractions.map((extraction, index) => ({
+      extractionId: normalizeClientExtractionId(extraction, index),
+      findingHash: hashJson(extraction.findings)
+    })),
     imports: input.imports.map((source) => ({
       sourceId: source.sourceId,
       textHash: hashJson(source.text)
@@ -7805,6 +8151,8 @@ function buildSessionReconciliationReport(input) {
     source_client: "wizard",
     session_id: sessionId,
     workspace: input.workspace,
+    extraction_protocol: buildWorkGraphExtractionProtocol(),
+    client_extractions: clientExtractionSummaries,
     source_coverage: coverage,
     final_state: inferFinalState(allFindings),
     events,
@@ -7821,6 +8169,46 @@ function buildSessionReconciliationReport(input) {
     raw_transcripts_sent: false
   };
 }
+function renderWorkGraphExtractionProtocolMarkdown(protocol = buildWorkGraphExtractionProtocol()) {
+  const lines = [];
+  lines.push("# OrgX Work Graph AI-Client Extraction Schema");
+  lines.push("");
+  lines.push(`Schema version: ${protocol.schema_version}`);
+  lines.push(`Mode: ${protocol.mode}`);
+  lines.push("");
+  lines.push("## Prompt");
+  lines.push("");
+  lines.push(protocol.prompt);
+  lines.push("");
+  lines.push("## Objective");
+  lines.push("");
+  lines.push(protocol.schema.objective);
+  lines.push("");
+  lines.push("## Search Lenses");
+  lines.push("");
+  for (const lens of protocol.schema.source_search_strategy) {
+    lines.push(`- ${lens.lens}: ${lens.query} Return when: ${lens.return_when}`);
+  }
+  lines.push("");
+  lines.push("## Quality Bar");
+  lines.push("");
+  for (const item of protocol.schema.quality_bar) {
+    lines.push(`- ${item}`);
+  }
+  lines.push("");
+  lines.push("## Reject As Noise");
+  lines.push("");
+  for (const item of protocol.schema.reject_as_noise) {
+    lines.push(`- ${item}`);
+  }
+  lines.push("");
+  lines.push("## Required JSON Shape");
+  lines.push("");
+  lines.push("```json");
+  lines.push(JSON.stringify(protocol.schema.required_output, null, 2));
+  lines.push("```");
+  return lines.join("\n");
+}
 function renderWorkGraphMarkdown(report) {
   const lines = [];
   lines.push("# OrgX Work Graph Reconciliation");
@@ -7832,6 +8220,26 @@ function renderWorkGraphMarkdown(report) {
   lines.push(`Hydration key: ${report.signup_hydration.hydration_key}`);
   lines.push(`Final state: ${report.final_state}`);
   lines.push("");
+  lines.push("## AI-Client Search Protocol");
+  lines.push("");
+  lines.push(`Schema: ${report.extraction_protocol.schema_version}`);
+  lines.push(report.extraction_protocol.prompt);
+  lines.push("");
+  lines.push("Search lenses:");
+  for (const lens of report.extraction_protocol.schema.source_search_strategy) {
+    lines.push(`- ${lens.lens}: ${lens.return_when}`);
+  }
+  lines.push("");
+  lines.push("## Client Extractions");
+  lines.push("");
+  if (report.client_extractions.length === 0) {
+    lines.push("- No structured AI-client extraction files were provided; fallback local session import was used.");
+  } else {
+    for (const extraction of report.client_extractions) {
+      lines.push(`- ${extraction.source_label}: ${extraction.finding_count} findings, ${extraction.query_count} queries, ${extraction.searched_source_count} source groups, confidence ${extraction.confidence}`);
+    }
+  }
+  lines.push("");
   lines.push("## Opportunity Score");
   lines.push("");
   lines.push(`Overall: ${report.opportunity_score.overall}/100`);
@@ -8380,6 +8788,29 @@ function parsePositiveInteger(value, fallback, label) {
   }
   return parsed;
 }
+function collectPathOption(value, previous = []) {
+  return [
+    ...previous,
+    ...value.split(",").map((item) => item.trim()).filter(Boolean)
+  ];
+}
+function parseClientExtractionFile(path) {
+  const resolvedPath = resolve(path);
+  const parsed = JSON.parse(readFileSync5(resolvedPath, "utf8"));
+  if (!isRecord(parsed)) {
+    throw new Error(`AI-client extraction must be a JSON object: ${resolvedPath}`);
+  }
+  if (!Array.isArray(parsed.findings)) {
+    throw new Error(`AI-client extraction must include findings[]: ${resolvedPath}`);
+  }
+  if (typeof parsed.source_client !== "string" || !parsed.source_client.trim()) {
+    throw new Error(`AI-client extraction must include source_client: ${resolvedPath}`);
+  }
+  return parsed;
+}
+function readClientExtractions(options) {
+  return (options.extraction ?? []).map(parseClientExtractionFile);
+}
 async function readAuditImports(options, interactive) {
   const sources = parseAiSessionSources(options.from);
   const imports = [];
@@ -8419,6 +8850,38 @@ async function readAuditImports(options, interactive) {
     missingSources
   };
 }
+async function readWorkGraphInputs(options, interactive) {
+  const clientExtractions = readClientExtractions(options);
+  const shouldReadSessionImports = Boolean(
+    options.from?.trim() || options.input?.trim() || clientExtractions.length === 0 || !process.stdin.isTTY && clientExtractions.length === 0
+  );
+  if (!shouldReadSessionImports) {
+    return {
+      clientExtractions,
+      connectedSources: [],
+      imports: [],
+      missingSources: []
+    };
+  }
+  let auditImports;
+  try {
+    auditImports = await readAuditImports(options, interactive);
+  } catch (error) {
+    if (clientExtractions.length === 0) throw error;
+    const message = error instanceof Error ? error.message : String(error);
+    auditImports = {
+      connectedSources: [],
+      imports: [],
+      missingSources: [`fallback session import: ${message}`]
+    };
+  }
+  return {
+    clientExtractions,
+    connectedSources: auditImports.connectedSources,
+    imports: auditImports.imports,
+    missingSources: auditImports.missingSources
+  };
+}
 function requireWriteApproval(options, interactive) {
   const wantsWrite = Boolean(options.createInitiative || options.attachToInitiative || options.writeFollowUp);
   if (!wantsWrite || options.yes || options.dryRun) return true;
@@ -8529,24 +8992,42 @@ async function runAuditCommand(options) {
     console.log(`  ${ICON.ok}  ${pc3.green("follow-up     ")} ${pc3.bold(followUp.title)} ${pc3.dim(followUp.id)}`);
   }
 }
+function runWorkGraphExtractionSchemaCommand(options) {
+  const protocol = buildWorkGraphExtractionProtocol();
+  const outputPath = options.output?.trim() ? resolve(options.output.trim()) : "";
+  if (outputPath) {
+    if (options.json) {
+      writeJsonFile(outputPath, protocol);
+    } else {
+      writeTextFile(outputPath, renderWorkGraphExtractionProtocolMarkdown(protocol));
+    }
+  }
+  if (options.json) {
+    console.log(JSON.stringify(protocol, null, 2));
+    return;
+  }
+  const markdown = renderWorkGraphExtractionProtocolMarkdown(protocol);
+  console.log(markdown);
+}
 async function runWorkGraphCommand(options, defaults = {}) {
   const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY);
   const commandOptions = {
     ...options,
     ...options.from?.trim() ? {} : defaults.from ? { from: defaults.from } : {}
   };
-  const auditImports = await readAuditImports(commandOptions, interactive);
+  const auditInputs = await readWorkGraphInputs(commandOptions, interactive);
   const workspace = await resolveAuditWorkspace(commandOptions);
   const report = buildSessionReconciliationReport({
+    clientExtractions: auditInputs.clientExtractions,
     connectedSources: [
-      ...auditImports.connectedSources,
+      ...auditInputs.connectedSources,
       ...workspace.id === "local-workspace" ? [] : ["OrgX workspace"]
     ],
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    imports: auditImports.imports,
+    imports: auditInputs.imports,
     missingSources: [
       ...workspace.id === "local-workspace" ? ["OrgX workspace auth"] : [],
-      ...auditImports.missingSources
+      ...auditInputs.missingSources
     ],
     workspace
   });
@@ -8567,6 +9048,7 @@ async function runWorkGraphCommand(options, defaults = {}) {
       finalState: report.final_state,
       opportunityScore: report.opportunity_score,
       missedOrchestration: report.missed_orchestration_opportunities.length,
+      clientExtractionCount: report.client_extractions.length,
       kickoffCount: report.initiative_kickoffs.length,
       trailCount: report.trails.length,
       recurringPatternCount: report.recurring_patterns.length,
@@ -8579,6 +9061,7 @@ async function runWorkGraphCommand(options, defaults = {}) {
   console.log(`  ${ICON.ok}  ${pc3.green("report id     ")} ${pc3.dim(report.report_id)}`);
   console.log(`  ${ICON.ok}  ${pc3.green("fingerprint   ")} ${pc3.dim(report.work_graph_fingerprint)}`);
   console.log(`  ${ICON.ok}  ${pc3.green("state         ")} ${pc3.dim(report.final_state)}`);
+  console.log(`  ${ICON.ok}  ${pc3.green("extractions   ")} ${pc3.dim(String(report.client_extractions.length))}`);
   console.log(`  ${ICON.ok}  ${pc3.green("score         ")} ${pc3.dim(formatWorkGraphScoreLine(report.opportunity_score))}`);
   const missed = report.missed_orchestration_opportunities.length;
   const missedColor = missed > 0 ? pc3.yellow : pc3.green;
@@ -9551,9 +10034,10 @@ 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.30" : void 0;
+  const pkgVersion = true ? "0.1.31" : void 0;
   program.version(pkgVersion ?? "unknown", "-V, --version");
-  program.hook("preAction", () => {
+  program.hook("preAction", (_thisCommand, actionCommand) => {
+    if (Boolean(actionCommand.optsWithGlobals().json)) return;
     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("--workspace", "choose or change the default workspace during setup").option("--daily-brief", "configure Daily Brief even if setup already handled it").option("--skip-daily-brief", "skip Daily Brief prompts and remember the skip").action(async (options) => {
@@ -10251,14 +10735,21 @@ async function main() {
     await runAuditCommand(options);
   });
   const workGraph = program.command("work-graph").description("Build a redacted OrgX Work Graph report from AI-client, Slack, MCP, or manual context.");
-  workGraph.command("preview").description("Preview the live Work Graph opportunity map without writing to OrgX.").option("--input <path>", "source transcript or summary file; stdin is used when piped").option("--from <sources>", "auto-import recent local AI sessions: codex, claude, or all").option("--session-limit <count>", "max recent sessions to import per selected source", "3").option("--session-days <days>", "lookback window for local AI-session imports", "30").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("extraction-schema").description("Print the AI-client search schema used to extract Work Graph Trails from sessions 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",
+      json: Boolean(options.json)
+    });
+    runWorkGraphExtractionSchemaCommand(options);
+  });
+  workGraph.command("preview").description("Preview the live Work Graph opportunity map 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: codex, claude, or all").option("--session-limit <count>", "max recent sessions to import per selected source", "3").option("--session-days <days>", "lookback window for local AI-session imports", "30").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 Work Graph Trails, Mirror, tensions, and launch recommendations.").option("--input <path>", "source transcript or summary file; stdin is used when piped").option("--from <sources>", "auto-import recent local AI sessions: codex, claude, or all").option("--session-limit <count>", "max recent sessions to import per selected source", "5").option("--session-days <days>", "lookback window for local AI-session imports", "30").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("--json", "emit a JSON command summary").action(async (options) => {
+  workGraph.command("profile").description("Build a local OrgX Profile with Work Graph Trails, Mirror, tensions, and launch 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: codex, claude, or all").option("--session-limit <count>", "max recent sessions to import per selected source", "5").option("--session-days <days>", "lookback window for local AI-session imports", "30").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("--json", "emit a JSON command summary").action(async (options) => {
     await safeTrackWizardTelemetry("work_graph_profile_started", {
       command: "work-graph profile",
       from: options.from ?? "manual"
@@ -10266,7 +10757,7 @@ async function main() {
     await runWorkGraphCommand(options);
   });
   const sessions = program.command("sessions").description("Inspect and reconcile local AI sessions into OrgX-ready Work Graph reports.");
-  sessions.command("reconcile").description("Backfill recent Codex and Claude sessions into a redacted Work Graph report.").option("--from <sources>", "auto-import recent local AI sessions: codex, claude, or all", "all").option("--session-limit <count>", "max recent sessions to import per selected source", "5").option("--session-days <days>", "lookback window for local AI-session imports", "7").option("--codex-sessions-dir <path>", "override Codex sessions directory for import").option("--claude-projects-dir <path>", "override Claude projects directory for import").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 reconciliation").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) => {
+  sessions.command("reconcile").description("Backfill recent Codex and Claude sessions into a redacted Work Graph report.").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: codex, claude, or all", "all").option("--session-limit <count>", "max recent sessions to import per selected source", "5").option("--session-days <days>", "lookback window for local AI-session imports", "7").option("--codex-sessions-dir <path>", "override Codex sessions directory for import").option("--claude-projects-dir <path>", "override Claude projects directory for import").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 reconciliation").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("sessions_reconcile_started", {
       command: "sessions reconcile",
       from: options.from ?? "all"