@useorgx/wizard 0.1.32 → 0.1.37

package/dist/cli.js

@@ -3,7 +3,7 @@
 // src/cli.ts
 import * as clack from "@clack/prompts";
 import { spawnSync as spawnSync3 } from "child_process";
-import { readFileSync as readFileSync5 } from "fs";
+import { readFileSync as readFileSync6 } from "fs";
 import { hostname } from "os";
 import { resolve } from "path";
 import { Command } from "commander";
@@ -6235,6 +6235,7 @@ var INSTRUCTION_BOILERPLATE_PATTERN = /^(?:#{1,6}\s*)?(?:agents\.md|instructions
 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 LABEL_VALUE_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*(?:["']?[\w-]+["']?\s*\|\s*["']?[\w-]+["']?|[\d\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;
@@ -6340,6 +6341,7 @@ function normalizeAuditRelevantLine(line) {
   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 (LABEL_VALUE_NOISE_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;
@@ -6416,19 +6418,32 @@ function readSessionImport(candidate, root, options) {
   const extractor = candidate.source === "codex" ? extractCodexMessageText : extractClaudeMessageText;
   const lines = readFileSync3(candidate.path, "utf8").split(/\r?\n/);
   const relevantLines = [];
+  let messageCount = 0;
   for (const line of lines) {
     const record = parseJsonLine(line);
     const text2 = extractor(record);
     if (!text2) continue;
+    messageCount += 1;
     relevantLines.push(...keepAuditRelevantLines(text2));
   }
   const deduped = [...new Set(relevantLines)].slice(0, 80);
   if (deduped.length === 0) return null;
   const relativePath = relative2(root, candidate.path);
   return {
-    sourceId: `${candidate.source}:${basename2(candidate.path, ".jsonl")}`,
-    sourceLabel: `${candidate.source === "codex" ? "Codex" : "Claude"} session ${relativePath}`,
-    text: deduped.join("\n")
+    import: {
+      sourceId: `${candidate.source}:${basename2(candidate.path, ".jsonl")}`,
+      sourceLabel: `${candidate.source === "codex" ? "Codex" : "Claude"} session ${relativePath}`,
+      metadata: {
+        bytes: stats.size,
+        message_count: messageCount,
+        relative_path: relativePath,
+        retained_line_count: deduped.length,
+        source_client: candidate.source
+      },
+      text: deduped.join("\n")
+    },
+    messageCount,
+    retainedLineCount: deduped.length
   };
 }
 function loadAiSessionImports(options) {
@@ -6443,7 +6458,9 @@ function loadAiSessionImports(options) {
   const imports = [];
   const connectedSources = [];
   const missingSources = [];
+  let retainedLines = 0;
   let scannedFiles = 0;
+  let scannedMessages = 0;
   let skippedFiles = 0;
   for (const source of options.sources) {
     const root = roots[source];
@@ -6456,12 +6473,14 @@ function loadAiSessionImports(options) {
     for (const candidate of candidates) {
       if (importedForSource >= limitPerSource) break;
       scannedFiles += 1;
-      const imported = readSessionImport(candidate, root, { maxBytesPerFile });
-      if (!imported) {
+      const result = readSessionImport(candidate, root, { maxBytesPerFile });
+      if (!result) {
         skippedFiles += 1;
         continue;
       }
-      imports.push(imported);
+      imports.push(result.import);
+      retainedLines += result.retainedLineCount;
+      scannedMessages += result.messageCount;
       importedForSource += 1;
     }
     if (importedForSource > 0) {
@@ -6474,7 +6493,9 @@ function loadAiSessionImports(options) {
     connectedSources,
     imports,
     missingSources,
+    retainedLines,
     scannedFiles,
+    scannedMessages,
     skippedFiles
   };
 }
@@ -6990,6 +7011,7 @@ var WORK_GRAPH_FINDING_TYPES = [
   "business",
   "product_surface",
   "goal",
+  "outcome",
   "initiative_candidate",
   "missed_orchestration_opportunity"
 ];
@@ -7022,6 +7044,10 @@ function sourceClientForImport(source) {
   if (raw.includes("slack")) return "slack";
   if (raw.includes("github")) return "github";
   if (raw.includes("linear")) return "linear";
+  if (raw.includes("gmail") || raw.includes("email")) return "gmail";
+  if (raw.includes("calendar") || raw.includes("meeting")) return "calendar";
+  if (raw.includes("notion")) return "notion";
+  if (raw.includes("doc")) return "docs";
   if (raw.includes("mcp")) return "mcp";
   if (raw.includes("api")) return "api";
   if (raw.includes("manual") || raw.includes("wizard-audit-input")) return "manual";
@@ -7030,7 +7056,7 @@ function sourceClientForImport(source) {
 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") {
+  if (normalized === "codex" || normalized === "claude" || normalized === "claude-code" || normalized === "cursor" || normalized === "openclaw" || normalized === "slack" || normalized === "mcp" || normalized === "github" || normalized === "linear" || normalized === "gmail" || normalized === "calendar" || normalized === "notion" || normalized === "docs" || normalized === "manual" || normalized === "wizard" || normalized === "api") {
     return normalized;
   }
   if (normalized.includes("claude")) return "claude";
@@ -7039,9 +7065,46 @@ function normalizeSourceClient(value) {
   if (normalized.includes("slack")) return "slack";
   if (normalized.includes("github")) return "github";
   if (normalized.includes("linear")) return "linear";
+  if (normalized.includes("gmail") || normalized.includes("email")) return "gmail";
+  if (normalized.includes("calendar") || normalized.includes("meeting")) return "calendar";
+  if (normalized.includes("notion")) return "notion";
+  if (normalized.includes("doc")) return "docs";
   if (normalized.includes("mcp")) return "mcp";
   return "unknown";
 }
+function sourceClientFromText(value) {
+  const normalized = value.toLowerCase();
+  if (/\bclaude(?:[- ]code)?\b|\.claude\/projects|claude:/.test(normalized)) return "claude";
+  if (/\bcodex\b|\.codex\/sessions|rollout-/.test(normalized)) return "codex";
+  if (/\bcursor\b/.test(normalized)) return "cursor";
+  if (/\bopenclaw\b/.test(normalized)) return "openclaw";
+  if (/\bslack\b/.test(normalized)) return "slack";
+  if (/\bgithub\b|\bgit:|pull request|commit\b/.test(normalized)) return "github";
+  if (/\blinear\b/.test(normalized)) return "linear";
+  if (/\bgmail\b|\bemail\b/.test(normalized)) return "gmail";
+  if (/\bcalendar\b|\bmeeting\b/.test(normalized)) return "calendar";
+  if (/\bnotion\b/.test(normalized)) return "notion";
+  if (/\bdocs?\b|google drive/.test(normalized)) return "docs";
+  if (/\bmcp\b|mcp__|orgx_emit|scaffold_initiative|ship_batch/.test(normalized)) return "mcp";
+  if (/\borgx api\b|\bapi\b/.test(normalized)) return "api";
+  return "unknown";
+}
+function sourceClientForExtractionFinding(extraction, finding) {
+  const explicit = normalizeSourceClient(finding.source_client);
+  if (explicit !== "unknown") return explicit;
+  const inferred = sourceClientFromText([
+    finding.source_id ?? "",
+    finding.source_label ?? "",
+    finding.evidence_ref ?? "",
+    finding.summary ?? ""
+  ].join("\n"));
+  if (inferred !== "unknown") return inferred;
+  return normalizeSourceClient(extraction.source_client);
+}
+function arrayOfStrings(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((item) => typeof item === "string" && item.trim().length > 0);
+}
 function normalizeFindingType(value) {
   if (typeof value !== "string") return null;
   const normalized = value.trim().toLowerCase();
@@ -7052,9 +7115,23 @@ function normalizeConfidence(value, fallback = 0.72) {
   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 lower = text2.toLowerCase();
+  if (lower.includes("mcp__orgx__list_entities") && lower.includes("zod")) {
+    return "OrgX MCP list_entities is failing schema validation";
+  }
+  if (lower.includes("scaffold_initiative") && lower.includes("auto_continue") && lower.includes("dispatch")) {
+    return "scaffold_initiative creates ready streams without dispatching agent runs";
+  }
+  if (lower.includes("operation qa loop") && lower.includes("0/") && lower.includes("entities")) {
+    return "OrgX scaffold fails to create Operation QA Loop entities";
+  }
+  if (lower.includes("production-only redirect") || lower.includes("livedemopageclient")) {
+    return "Production route behavior changed without durable approval";
+  }
+  const normalized = text2.replace(/[`*_>#]/g, "").replace(/^\s*[-*\d.)]+\s*/, "").replace(/^\s*(decision|artifact|commitment|next action|follow[- ]?up|outcome|roi|economics|open loop|gap|blocker|risk|goal|summary)\s*:\s*/i, "").replace(/^\s*(fix|fixing|debug|investigate|continue|todo)\s+(the\s+)?(bug|issue|problem)\s*[:.-]?\s*/i, "").replace(/^\s*one\s+bug\s+surfaced\s*:\s*/i, "").replace(/\s+/g, " ").trim();
   const firstSentence = normalized.split(/[.!?]\s/)[0]?.trim() || normalized;
-  return (firstSentence || fallback).slice(0, 160);
+  const firstClause = firstSentence.split(/\s[-:;]\s/)[0]?.trim() || firstSentence;
+  return (firstClause || fallback).slice(0, 110);
 }
 function normalizeClientExtractionId(extraction, index) {
   return extraction.extraction_id?.trim() || `${extraction.source_client || "unknown"}:client-extraction:${index + 1}`;
@@ -7074,43 +7151,49 @@ function buildWorkGraphExtractionProtocol() {
     source_search_strategy: [
       {
         id: "decisions",
-        lens: "Decision trails",
+        lens: "Decision evidence",
         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",
+        lens: "Artifact evidence",
         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",
+        lens: "Blocker evidence",
         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.",
+        lens: "People and business context",
+        query: "Find users, customers, buyers, stakeholders, reviewers, teams, businesses, accounts, deal context, support signals, 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: "coordination_sources",
+        lens: "Coordination and calendar/email context",
+        query: "Find Slack threads, emails, meetings, docs, handoffs, approvals, owner changes, follow-ups, and coordination gaps that explain how work moved or stalled outside the AI client.",
+        return_when: "The coordination source proves ownership, urgency, approval, customer context, or a missing source needed for attribution."
+      },
       {
         id: "product_surfaces",
-        lens: "Product surface trails",
+        lens: "Product surface coverage",
         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",
+        lens: "Agent, skill, tool, and source usage",
         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",
+        lens: "Outcome and ROI evidence",
         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."
       },
@@ -7119,18 +7202,30 @@ function buildWorkGraphExtractionProtocol() {
         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."
+      },
+      {
+        id: "domains",
+        lens: "Domain coverage",
+        query: "Find which domains the work spans: product/UX, agents/runtime, MCP/platform, wizard/CLI, plugin distribution, source integrations, quality verification, GTM, sales, operations, and business leverage.",
+        return_when: "A domain has concrete work evidence, not just a generic mention."
+      },
+      {
+        id: "skills_tools",
+        lens: "Commonly invoked skills, agents, and tools",
+        query: "Find named skills, OrgX domain agents, MCP tools, client tools, commands, test tools, and source systems that shaped the work.",
+        return_when: "A skill/tool/source was used, requested, blocked, missed, or repeatedly referenced as part of execution."
       }
     ],
     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_client: "codex | claude | claude-code | cursor | openclaw | slack | mcp | github | linear | gmail | calendar | notion | docs | manual | api | unknown",
       source_label: "human-readable source label",
       searched_sources: ["session/log/source group names searched"],
       search_queries: [
         {
           id: "decisions",
-          lens: "Decision trails",
+          lens: "Decision evidence",
           query: "query actually used",
           result_count: 0
         }
@@ -7143,9 +7238,10 @@ function buildWorkGraphExtractionProtocol() {
       },
       findings: [
         {
-          type: "decision | artifact | blocker | person | business | product_surface | goal | action | initiative_candidate | missed_orchestration_opportunity",
+          type: "decision | artifact | blocker | person | business | product_surface | goal | outcome | action | initiative_candidate | missed_orchestration_opportunity",
           title: "short durable title, not a raw line",
           summary: "one sentence explaining why this matters",
+          source_client: "optional override when a blended extractor found evidence from another client",
           source_id: "session/tool/source id",
           source_label: "source label",
           evidence_ref: "stable evidence pointer",
@@ -7164,12 +7260,13 @@ function buildWorkGraphExtractionProtocol() {
       ]
     },
     quality_bar: [
-      "Search broadly before summarizing; do not stop at the newest session if older sessions contain recurrence.",
+      "Search broadly through message turns 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.",
+      "A durable finding 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.",
+      "Extract the range of work domains and common skills/tools so the reader can see what kinds of work the audit actually understood.",
       "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."
     ],
@@ -7184,10 +7281,10 @@ function buildWorkGraphExtractionProtocol() {
     ]
   };
   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.",
+    "You are running the OrgX AI-client audit skill from your own session/search logs.",
+    "Search across available local message turns, 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."
+    "The output will create public-safe OrgX evidence paths, so every finding must be evidence-bearing and useful enough for a human to inspect."
   ].join(" ");
   return {
     schema_version: WORK_GRAPH_EXTRACTION_SCHEMA_VERSION,
@@ -7219,6 +7316,12 @@ function includesAny2(text2, patterns) {
   return patterns.some((pattern) => pattern.test(text2));
 }
 function buildCoverage(imports, connectedSources, missingSources, clientExtractions = []) {
+  const findings = buildClientExtractionFindings(clientExtractions);
+  const sourceClients = sortedUnique([
+    ...imports.map(sourceClientForImport),
+    ...findings.map((finding) => finding.source_client),
+    ...clientExtractions.map((extraction) => normalizeSourceClient(extraction.source_client))
+  ].filter((source) => source !== "unknown"));
   const extractionText = clientExtractions.flatMap((extraction) => [
     extraction.source_client,
     extraction.source_label ?? "",
@@ -7235,15 +7338,170 @@ ${extractionText}`.toLowerCase();
   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);
   const skillOnlySignal = orgxObserved && !orgxMcpCalled && /\bskill|instructions|agent|workflow\b/i.test(allText);
+  const normalizedConnectedSources = sortedUnique(
+    connectedSources.map((source) => {
+      const client = sourceClientFromText(source);
+      return client === "unknown" ? source : labelForSourceClient(client);
+    })
+  );
+  const inferredConnected = [
+    ...normalizedConnectedSources,
+    ...sourceClients.includes("codex") ? ["Codex sessions"] : [],
+    ...sourceClients.includes("claude") || sourceClients.includes("claude-code") ? ["Claude Code sessions"] : [],
+    ...sourceClients.includes("github") ? ["Git/GitHub proof"] : [],
+    ...sourceClients.includes("mcp") ? ["MCP tool telemetry"] : [],
+    ...sourceClients.includes("slack") ? ["Slack coordination"] : []
+  ];
+  const inferredMissing = [
+    ...missingSources,
+    ...sourceClients.includes("slack") ? [] : ["Slack coordination"],
+    ...sourceClients.includes("github") ? [] : ["GitHub PR/commit proof"],
+    ...allText.includes("hook") || allText.includes("outbox") ? [] : ["Runtime hook outbox replay"]
+  ];
+  const connected = sortedUnique(inferredConnected.filter(Boolean));
+  const missing = sortedUnique(inferredMissing.filter((source) => !connected.includes(source)));
+  const manifests = buildSourceCoverageManifests({
+    clientExtractions,
+    connectedSources: connected,
+    findings,
+    imports,
+    missingSources: missing
+  });
+  const partialCount = manifests.filter((manifest) => manifest.status === "partial").length;
+  const coverageScore = clampScore2(
+    28 + Math.min(34, connected.length * 7) + Math.min(18, findings.length * 2) + (sourceClients.includes("codex") ? 6 : 0) + (sourceClients.includes("claude") || sourceClients.includes("claude-code") ? 6 : 0) - missing.length * 7 - partialCount * 3
+  );
   return {
-    connected: [...connectedSources],
-    missing: [...missingSources],
+    connected,
+    missing,
     mcpObserved,
     orgxObserved,
     orgxMcpCalled,
-    skillOnlySignal
+    skillOnlySignal,
+    coverage_score: coverageScore,
+    manifests,
+    notes: [
+      "OrgX/MCP writeback is one coverage signal; it is not required for the audit to find useful work.",
+      missing.length > 0 ? `Coverage is limited by missing sources: ${missing.join(", ")}.` : "Connected sources are sufficient for a first-pass operating profile, but still require user review."
+    ]
   };
 }
+function buildSourceCoverageManifests(input) {
+  const manifests = /* @__PURE__ */ new Map();
+  const addManifest = (manifest) => {
+    const sourceLabel2 = canonicalSourceManifestLabel(manifest);
+    const key = `${manifest.source_client}:${sourceLabel2}`;
+    const previous = manifests.get(key);
+    if (!previous) {
+      manifests.set(key, { ...manifest, source_label: sourceLabel2 });
+      return;
+    }
+    manifests.set(key, {
+      ...previous,
+      source_label: sourceLabel2,
+      status: previous.status === "connected" || manifest.status === "connected" ? "connected" : previous.status === "partial" || manifest.status === "partial" ? "partial" : "missing",
+      searched_sources: sortedUnique([...previous.searched_sources, ...manifest.searched_sources]),
+      searched_session_count: previous.searched_session_count + manifest.searched_session_count,
+      skipped_session_count: previous.skipped_session_count + manifest.skipped_session_count,
+      query_count: previous.query_count + manifest.query_count,
+      finding_count: previous.finding_count + manifest.finding_count,
+      confidence: Math.max(previous.confidence, manifest.confidence),
+      notes: sortedUnique([...previous.notes, ...manifest.notes])
+    });
+  };
+  for (const extraction of input.clientExtractions) {
+    const extractionFindings = buildClientExtractionFindings([extraction]);
+    const byClient = /* @__PURE__ */ new Map();
+    for (const finding of extractionFindings) {
+      byClient.set(finding.source_client, [...byClient.get(finding.source_client) ?? [], finding]);
+    }
+    for (const [sourceClient, findings] of byClient) {
+      const searchedSources = extraction.searched_sources ?? [];
+      addManifest({
+        source_client: sourceClient,
+        source_label: labelForSourceClient(sourceClient),
+        status: findings.length > 0 ? "connected" : "partial",
+        searched_sources: searchedSources,
+        searched_session_count: extraction.extraction_quality?.searched_session_count ?? 0,
+        skipped_session_count: extraction.extraction_quality?.skipped_session_count ?? 0,
+        query_count: extraction.search_queries?.length ?? 0,
+        finding_count: findings.length,
+        confidence: normalizeConfidence(extraction.extraction_quality?.confidence, 0.74),
+        notes: extraction.extraction_quality?.notes ?? []
+      });
+    }
+  }
+  for (const source of input.imports) {
+    const sourceClient = sourceClientForImport(source);
+    addManifest({
+      source_client: sourceClient,
+      source_label: source.sourceLabel,
+      status: "connected",
+      searched_sources: [source.sourceId],
+      searched_session_count: 1,
+      skipped_session_count: 0,
+      query_count: 0,
+      finding_count: input.findings.filter((finding) => finding.source_id === source.sourceId).length,
+      confidence: 0.62,
+      notes: ["Fallback line-level import; lower confidence than client-native extraction."]
+    });
+  }
+  for (const source of input.missingSources) {
+    addManifest({
+      source_client: sourceClientFromText(source),
+      source_label: source,
+      status: "missing",
+      searched_sources: [],
+      searched_session_count: 0,
+      skipped_session_count: 0,
+      query_count: 0,
+      finding_count: 0,
+      confidence: 0,
+      notes: ["Not connected or not searched in this audit pass."]
+    });
+  }
+  return [...manifests.values()].sort((left, right) => {
+    const rank = { connected: 0, partial: 1, missing: 2 };
+    return rank[left.status] - rank[right.status] || right.finding_count - left.finding_count;
+  });
+}
+function canonicalSourceManifestLabel(manifest) {
+  if (manifest.source_client === "codex" || manifest.source_client === "claude" || manifest.source_client === "claude-code") {
+    return labelForSourceClient(manifest.source_client);
+  }
+  if (manifest.source_client === "github" || manifest.source_client === "slack" || manifest.source_client === "mcp") {
+    return labelForSourceClient(manifest.source_client);
+  }
+  return manifest.source_label;
+}
+function labelForSourceClient(sourceClient) {
+  switch (sourceClient) {
+    case "codex":
+      return "Codex sessions";
+    case "claude":
+    case "claude-code":
+      return "Claude Code sessions";
+    case "mcp":
+      return "MCP tool telemetry";
+    case "github":
+      return "Git/GitHub proof";
+    case "slack":
+      return "Slack coordination";
+    case "linear":
+      return "Linear issues";
+    case "gmail":
+      return "Email coordination";
+    case "calendar":
+      return "Calendar/meeting context";
+    case "wizard":
+      return "Wizard audit layer";
+    case "notion":
+    case "docs":
+      return "Docs";
+    default:
+      return sourceClient.replace(/[-_]/g, " ").replace(/\b\w/g, (char) => char.toUpperCase());
+  }
+}
 function summarizeClientExtractions(clientExtractions) {
   return clientExtractions.map((extraction, index) => {
     const extractionId = normalizeClientExtractionId(extraction, index);
@@ -7252,9 +7510,12 @@ function summarizeClientExtractions(clientExtractions) {
       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,
+      searched_session_count: extraction.extraction_quality?.searched_session_count ?? 0,
+      skipped_session_count: extraction.extraction_quality?.skipped_session_count ?? 0,
       query_count: extraction.search_queries?.length ?? 0,
       finding_count: extraction.findings.length,
-      confidence: normalizeConfidence(extraction.extraction_quality?.confidence, 0.74)
+      confidence: normalizeConfidence(extraction.extraction_quality?.confidence, 0.74),
+      notes: extraction.extraction_quality?.notes ?? []
     };
   });
 }
@@ -7275,21 +7536,78 @@ function buildClientExtractionEvents(clientExtractions) {
       finding_count: summary.finding_count,
       query_count: summary.query_count,
       searched_source_count: summary.searched_source_count,
+      searched_session_count: summary.searched_session_count,
+      skipped_session_count: summary.skipped_session_count,
       raw_transcript_sent: false
     }
   }));
 }
+function numberFromImportMetadata(source, key) {
+  const value = source.metadata?.[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function buildAuditMethod(input) {
+  const extractionSummaries = summarizeClientExtractions(input.clientExtractions);
+  const nativePacks = extractionSummaries.filter((summary) => summary.source_client === "codex" || summary.source_client === "claude" || summary.source_client === "claude-code").map((summary) => ({
+    source_client: summary.source_client,
+    source_label: summary.source_label,
+    searched_session_count: summary.searched_session_count,
+    finding_count: summary.finding_count,
+    confidence: summary.confidence
+  }));
+  const searchedMessages = input.imports.reduce(
+    (total, source) => total + numberFromImportMetadata(source, "message_count"),
+    0
+  );
+  const retainedLines = input.imports.reduce((total, source) => {
+    const explicit = numberFromImportMetadata(source, "retained_line_count");
+    return total + (explicit || source.text.split(/\r?\n/).filter(Boolean).length);
+  }, 0);
+  const skippedFiles = input.imports.reduce(
+    (total, source) => total + numberFromImportMetadata(source, "skipped_file_count"),
+    0
+  );
+  const extractionSearchedSessions = extractionSummaries.reduce(
+    (total, summary) => total + summary.searched_session_count,
+    0
+  );
+  const extractionSkippedSessions = extractionSummaries.reduce(
+    (total, summary) => total + summary.skipped_session_count,
+    0
+  );
+  const sourceGroups = sortedUnique([
+    ...input.imports.map((source) => source.sourceLabel),
+    ...input.clientExtractions.flatMap((extraction) => extraction.searched_sources ?? [])
+  ]);
+  return {
+    mode: "ai_client_session_search",
+    searched_session_files: input.imports.length + extractionSearchedSessions,
+    skipped_session_files: skippedFiles + extractionSkippedSessions,
+    searched_message_count: searchedMessages,
+    retained_evidence_lines: retainedLines,
+    searched_source_groups: sourceGroups.length,
+    extraction_lenses: input.extractionProtocol.schema.source_search_strategy.map((lens) => lens.lens),
+    client_native_packs: nativePacks,
+    privacy_contract: input.extractionProtocol.schema.privacy_contract,
+    notes: [
+      "The wizard reads local Codex/Claude message turns, filters out guardrails/code noise, then runs native extraction packs over the retained evidence lines.",
+      "Counts describe local files/message turns inspected before redaction; raw transcripts are not stored in the report.",
+      nativePacks.length > 0 ? "Codex/Claude native packs classified session evidence into decisions, artifacts, blockers, domains, skills/tools, and missed writeback signals." : "No native AI-client pack produced findings; this report is fallback-import only."
+    ]
+  };
+}
 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`;
+    const extractionSourceClient = normalizeSourceClient(extraction.source_client);
+    const sourceLabel2 = extraction.source_label?.trim() || `${extractionSourceClient} 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;
+      const sourceClient = sourceClientForExtractionFinding(extraction, finding);
       findings.push({
         type,
         title: title.slice(0, 180),
@@ -7299,7 +7617,7 @@ function buildClientExtractionFindings(clientExtractions) {
         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,
+          source_label: finding.source_label?.trim() || sourceLabel2,
           extraction_id: extractionId,
           schema_version: extraction.schema_version ?? null,
           occurred_at: finding.occurred_at ?? null,
@@ -7313,6 +7631,135 @@ function buildClientExtractionFindings(clientExtractions) {
   });
   return findings;
 }
+function nativeExtractionFindingType(line) {
+  const lower = line.toLowerCase();
+  if (/^\s*(?:decision|decided|choice|approved|rejected)\s*:/i.test(line)) return "decision";
+  if (/^\s*(?:artifact|receipt|proof)\s*:/i.test(line)) return "artifact";
+  if (/^\s*(?:outcome|result|impact)\s*:/i.test(line)) return "outcome";
+  if (/^\s*(?:roi|economics)\s*:/i.test(line)) return "business";
+  if (/^\s*(?:next action|follow[- ]?up|commitment)\s*:/i.test(line)) return "action";
+  if (/^\s*(?:blocker|risk|gap|open loop|rollback)\s*:/i.test(line)) return lower.includes("source") ? "missed_orchestration_opportunity" : "blocker";
+  if (/\b(?:failed|fails|error|invalid|unavailable|timeout|timed out|not called|not dispatched|missing|broken)\b/i.test(line)) {
+    if (/\b(?:tool|mcp|orgx|writeback|source|hook|outbox)\b/i.test(line)) return "missed_orchestration_opportunity";
+    return "blocker";
+  }
+  if (/\b(?:created|generated|implemented|shipped|verified|passed)\b/i.test(line)) return "artifact";
+  if (/\b(?:owner|dri|assigned)\b/i.test(line)) return "person";
+  if (/\b(?:initiative|workstream|milestone|launch|goal)\b/i.test(line)) return "goal";
+  return null;
+}
+function nativeEpisodeType(line) {
+  if (/\b(?:plan|decide|decision|choice|tradeoff|approve|reject)\b/i.test(line)) return "planning";
+  if (/\b(?:implemented|created|generated|edited|file|diff|commit|artifact)\b/i.test(line)) return "implementation";
+  if (/\b(?:failed|fails|error|timeout|invalid|debug|retry|blocked|blocker)\b/i.test(line)) return "debugging";
+  if (/\b(?:verified|passed|test|browser|qa|proof|outcome)\b/i.test(line)) return "verification";
+  return "handoff";
+}
+function nativeFindingConfidence(type, line) {
+  let confidence = type === "decision" || type === "artifact" || type === "outcome" ? 0.78 : 0.72;
+  if (/^\s*(?:decision|artifact|blocker|outcome|proof|result|next action|open loop|risk|gap)\s*:/i.test(line)) confidence += 0.08;
+  if (/\b(?:mcp__orgx__|scaffold_initiative|orgx_emit_activity|complete_with_proof|github|codex|claude)\b/i.test(line)) confidence += 0.05;
+  if (line.length < 32) confidence -= 0.1;
+  return normalizeConfidence(confidence, 0.72);
+}
+function nativeRelatedEntityNames(line) {
+  const candidates = [
+    ...Array.from(line.matchAll(/`([^`]{3,80})`/g)).map((match) => match[1] ?? ""),
+    ...Array.from(line.matchAll(/\b(?:OrgX|MCP|Codex|Claude|Slack|GitHub|Cursor|ChatGPT|Work Graph|Profile|Scaffold Initiative|Operation QA Loop|Runtime Hook|Eject Bay|Trail Inspector)\b/gi)).map((match) => match[0] ?? "")
+  ];
+  return sortedUnique(
+    candidates.map((candidate) => candidate.trim()).filter((candidate) => candidate.length >= 3).slice(0, 8)
+  );
+}
+function supportsNativeExtraction(sourceClient) {
+  return sourceClient === "codex" || sourceClient === "claude" || sourceClient === "claude-code";
+}
+function buildNativeAiClientExtractions(imports, generatedAt = (/* @__PURE__ */ new Date()).toISOString()) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const source of imports) {
+    const sourceClient = sourceClientForImport(source);
+    if (!supportsNativeExtraction(sourceClient)) continue;
+    const bucket = grouped.get(sourceClient) ?? {
+      findings: [],
+      searchedSources: [],
+      searchedSessionCount: 0,
+      skippedSessionCount: 0
+    };
+    bucket.searchedSources.push(source.sourceId);
+    bucket.searchedSessionCount += 1;
+    source.text.split(/\r?\n/).forEach((line, lineIndex) => {
+      const trimmed = line.trim();
+      if (!trimmed) return;
+      const type = nativeExtractionFindingType(trimmed);
+      if (!type) {
+        bucket.skippedSessionCount += 1;
+        return;
+      }
+      bucket.findings.push({
+        type,
+        title: titleFromText(trimmed, type.replace(/_/g, " ")),
+        summary: trimmed,
+        source_client: sourceClient,
+        source_id: source.sourceId,
+        source_label: source.sourceLabel,
+        evidence_ref: `${source.sourceId}:native:${lineIndex + 1}`,
+        confidence: nativeFindingConfidence(type, trimmed),
+        occurred_at: generatedAt,
+        redacted_verbatim: trimmed.slice(0, 420),
+        privacy_state: "redacted",
+        metadata: {
+          episode_type: nativeEpisodeType(trimmed),
+          related_entity_names: nativeRelatedEntityNames(trimmed),
+          related_source_ids: [source.sourceId],
+          state: type === "blocker" || type === "missed_orchestration_opportunity" ? "blocked" : type === "outcome" || type === "artifact" ? "verified" : "observed"
+        }
+      });
+    });
+    grouped.set(sourceClient, bucket);
+  }
+  return [...grouped.entries()].filter(([, bucket]) => bucket.findings.length > 0).map(([sourceClient, bucket]) => ({
+    schema_version: WORK_GRAPH_EXTRACTION_SCHEMA_VERSION,
+    extraction_id: `${sourceClient}:native-extraction:${shortHash({
+      sources: bucket.searchedSources,
+      findings: bucket.findings.map((finding) => finding.evidence_ref)
+    }, 12)}`,
+    source_client: sourceClient,
+    source_label: `${labelForSourceClient(sourceClient)} native extraction`,
+    searched_sources: sortedUnique(bucket.searchedSources),
+    search_queries: buildWorkGraphExtractionProtocol().schema.source_search_strategy.map((lens) => ({
+      id: lens.id,
+      lens: lens.lens,
+      query: lens.query,
+      result_count: bucket.findings.filter((finding) => {
+        const text2 = `${finding.title ?? ""}
+${finding.summary ?? ""}`;
+        if (lens.id === "decisions") return finding.type === "decision";
+        if (lens.id === "artifacts") return finding.type === "artifact";
+        if (lens.id === "blockers") return finding.type === "blocker" || finding.type === "missed_orchestration_opportunity";
+        if (lens.id === "people_businesses") return finding.type === "person" || finding.type === "business";
+        if (lens.id === "product_surfaces") return finding.type === "product_surface" || /\b(surface|profile|wizard|plugin|mcp)\b/i.test(text2);
+        if (lens.id === "agents_tools_sources") return /\b(agent|skill|tool|mcp|codex|claude|github|slack)\b/i.test(text2);
+        if (lens.id === "outcomes_roi") return finding.type === "outcome" || finding.type === "business";
+        if (lens.id === "domains") return nativeRelatedEntityNames(text2).length > 0;
+        if (lens.id === "skills_tools") return /\b(orgx-design|agent|skill|tool|mcp|codex|claude|github|slack)\b/i.test(text2);
+        return bucket.findings.length > 1 ? 1 : 0;
+      }).length
+    })),
+    extraction_quality: {
+      confidence: normalizeConfidence(
+        bucket.findings.reduce((total, finding) => total + (finding.confidence ?? 0.72), 0) / bucket.findings.length,
+        0.74
+      ),
+      searched_session_count: bucket.searchedSessionCount,
+      skipped_session_count: bucket.skippedSessionCount,
+      notes: [
+        "Auto-generated by orgx-wizard from local AI-client session imports.",
+        "Raw transcripts are excluded; only redacted evidence snippets and source refs are retained."
+      ]
+    },
+    findings: bucket.findings
+  }));
+}
 function buildDerivedFindings(imports) {
   const findings = [];
   let derivedIndex = 0;
@@ -7361,6 +7808,101 @@ function buildDerivedFindings(imports) {
   }
   return findings;
 }
+var WORK_GRAPH_DOMAIN_RULES = [
+  {
+    id: "domain:orgx-agents-runtime",
+    label: "OrgX agents and runtime",
+    summary: "Agent orchestration, MCP writeback, hooks, approvals, and runtime governance.",
+    patterns: [/\bagent\b/i, /\bsubagent\b/i, /\bmcp\b/i, /\bhook\b/i, /\bwriteback\b/i, /\borgx_emit\b/i, /\bscaffold_initiative\b/i]
+  },
+  {
+    id: "domain:wizard-cli",
+    label: "Wizard and CLI",
+    summary: "OrgX Wizard setup, audit/profile generation, local release, and onboarding commands.",
+    patterns: [/\bwizard\b/i, /\bcli\b/i, /\bnpm\b/i, /\brelease\b/i, /\bpublish\b/i, /\bwork-graph\b/i, /\bsessions reconcile\b/i]
+  },
+  {
+    id: "domain:public-profile-ux",
+    label: "Public profile and UX",
+    summary: "Shareable readout, claim flow, mobile/desktop layout, evidence inspection, and profile copy.",
+    patterns: [/\bprofile\b/i, /\bpublic readout\b/i, /\bclaim\b/i, /\bmobile\b/i, /\bdesktop\b/i, /\bux\b/i, /\bmirror\b/i, /\btrail inspector\b/i]
+  },
+  {
+    id: "domain:plugins-integrations",
+    label: "Plugins and integrations",
+    summary: "Codex, Claude Code, Cursor/OpenClaw, Slack, GitHub, Linear, and source coverage work.",
+    patterns: [/\bplugin\b/i, /\bcodex\b/i, /\bclaude\b/i, /\bcursor\b/i, /\bopenclaw\b/i, /\bslack\b/i, /\bgithub\b/i, /\blinear\b/i]
+  },
+  {
+    id: "domain:quality-verification",
+    label: "Quality and verification",
+    summary: "Tests, browser QA, type checks, release proof, and stale/fixed verification.",
+    patterns: [/\btest\b/i, /\btypecheck\b/i, /\bqa\b/i, /\bverified\b/i, /\bproof\b/i, /\bplaywright\b/i, /\bbrowser\b/i, /\bci\b/i]
+  },
+  {
+    id: "domain:gtm-business",
+    label: "GTM and business leverage",
+    summary: "ICP framing, pricing/value estimates, outreach, buyers, revenue, and market-facing proof.",
+    patterns: [/\bicp\b/i, /\bbuyer\b/i, /\bpricing\b/i, /\brevenue\b/i, /\bsales\b/i, /\bmarketing\b/i, /\bgtm\b/i, /\boperator leverage\b/i]
+  }
+];
+function buildDomainCoverage(findings) {
+  const signals = WORK_GRAPH_DOMAIN_RULES.map((rule) => {
+    const matched = findings.filter((finding) => {
+      const text2 = `${finding.title}
+${finding.summary}
+${finding.metadata.redacted_verbatim ?? ""}`;
+      return rule.patterns.some((pattern) => pattern.test(text2));
+    });
+    if (matched.length === 0) return null;
+    return {
+      id: rule.id,
+      label: rule.label,
+      summary: rule.summary,
+      finding_count: matched.length,
+      source_clients: sortedUnique(matched.map((finding) => finding.source_client)),
+      evidence_refs: sortedUnique(matched.map((finding) => finding.evidence_ref)).slice(0, 12),
+      confidence: Number((matched.reduce((total, finding) => total + finding.confidence, 0) / matched.length).toFixed(2))
+    };
+  }).filter((signal) => Boolean(signal));
+  return signals.sort((left, right) => right.finding_count - left.finding_count || right.confidence - left.confidence).slice(0, 8);
+}
+var SKILL_TOOL_RULES = [
+  { id: "skill:orgx-design", kind: "skill", label: "orgx-design", pattern: /\borgx-design\b|\$orgx-design/i },
+  { id: "skill:runtime-reporting", kind: "skill", label: "orgx-runtime-reporting", pattern: /\borgx-runtime-reporting\b|runtime reporting/i },
+  { id: "skill:initiative-ops", kind: "skill", label: "orgx-initiative-ops", pattern: /\borgx-initiative-ops\b|initiative ops/i },
+  { id: "agent:engineering", kind: "agent", label: "engineering-agent", pattern: /\bengineering-agent\b|engineering agent/i },
+  { id: "agent:design", kind: "agent", label: "design-agent", pattern: /\bdesign-agent\b|design agent/i },
+  { id: "agent:product", kind: "agent", label: "product-agent", pattern: /\bproduct-agent\b|product agent/i },
+  { id: "agent:orchestrator", kind: "agent", label: "orchestrator-agent", pattern: /\borchestrator-agent\b|orchestrator agent/i },
+  { id: "tool:orgx-list-entities", kind: "mcp_tool", label: "mcp__orgx__list_entities", pattern: /\bmcp__orgx__list_entities\b/i },
+  { id: "tool:scaffold", kind: "mcp_tool", label: "scaffold_initiative", pattern: /\bscaffold_initiative\b/i },
+  { id: "tool:complete-proof", kind: "mcp_tool", label: "complete_with_proof", pattern: /\bcomplete_with_proof\b/i },
+  { id: "tool:ship-batch", kind: "mcp_tool", label: "ship_batch", pattern: /\bship_batch\b/i },
+  { id: "client:codex", kind: "client_tool", label: "Codex", pattern: /\bcodex\b/i },
+  { id: "client:claude", kind: "client_tool", label: "Claude Code", pattern: /\bclaude(?: code)?\b/i },
+  { id: "source:github", kind: "source", label: "GitHub", pattern: /\bgithub\b|\bpull request\b|\bcommit\b/i },
+  { id: "source:slack", kind: "source", label: "Slack", pattern: /\bslack\b/i }
+];
+function buildSkillToolSignals(findings) {
+  return SKILL_TOOL_RULES.map((rule) => {
+    const matched = findings.filter(
+      (finding) => rule.pattern.test(`${finding.title}
+${finding.summary}
+${finding.metadata.redacted_verbatim ?? ""}`)
+    );
+    if (matched.length === 0) return null;
+    return {
+      id: rule.id,
+      label: rule.label,
+      kind: rule.kind,
+      mention_count: matched.length,
+      source_clients: sortedUnique(matched.map((finding) => finding.source_client)),
+      evidence_refs: sortedUnique(matched.map((finding) => finding.evidence_ref)).slice(0, 12),
+      confidence: Number((matched.reduce((total, finding) => total + finding.confidence, 0) / matched.length).toFixed(2))
+    };
+  }).filter((signal) => Boolean(signal)).sort((left, right) => right.mention_count - left.mention_count || right.confidence - left.confidence).slice(0, 12);
+}
 function buildWorkGraphEvents(imports) {
   return imports.map((source, index) => ({
     schema_version: WORK_GRAPH_SCHEMA_VERSION,
@@ -7373,6 +7915,7 @@ function buildWorkGraphEvents(imports) {
     metadata: {
       import_index: index,
       line_count: source.text.split(/\r?\n/).filter(Boolean).length,
+      ...source.metadata ?? {},
       raw_transcript_sent: false
     }
   }));
@@ -7466,9 +8009,84 @@ function scoreOpportunity(coverage, findings) {
     orgx_fit: orgxFit
   };
 }
+function estimateImpactProjection(input) {
+  const { coverage, findings, opportunityScore, patterns, trails } = input;
+  const blockerEvents = trails.filter((trail) => trail.subject_entity_type === "blocker").reduce((total, trail) => total + Math.max(1, trail.events.length), 0);
+  const decisionEvents = trails.filter((trail) => trail.subject_entity_type === "decision").reduce((total, trail) => total + Math.max(1, trail.events.length), 0);
+  const artifactEvents = trails.filter((trail) => trail.subject_entity_type === "artifact").reduce((total, trail) => total + Math.max(1, trail.events.length), 0);
+  const missedCount = findings.filter((finding) => finding.type === "missed_orchestration_opportunity").length;
+  const repeatedEvents = trails.filter((trail) => trail.events.length > 1).reduce((total, trail) => total + trail.events.length, 0);
+  const rawHours = blockerEvents * 0.75 + decisionEvents * 0.45 + artifactEvents * 0.25 + missedCount * 0.65 + repeatedEvents * 0.35 + coverage.missing.length * 0.4;
+  const hours = Number(Math.max(0.5, Math.min(40, rawHours)).toFixed(1));
+  const acceleration = clampScore2(
+    6 + Math.round(opportunityScore.automation_potential * 0.22) + patterns.filter((pattern) => pattern.severity === "critical" || pattern.severity === "high").length * 5 + (coverage.manifests?.filter((manifest) => manifest.status === "connected").length ?? 0) * 2
+  );
+  const confidenceInputs = [
+    ...findings.map((finding) => finding.confidence),
+    ...patterns.map((pattern) => pattern.confidence),
+    coverage.coverage_score ? coverage.coverage_score / 100 : 0.55
+  ];
+  const confidence = Number((confidenceInputs.reduce((total, value) => total + value, 0) / Math.max(1, confidenceInputs.length)).toFixed(2));
+  return {
+    time_saved_hours_per_week: hours,
+    acceleration_percent: Math.min(70, acceleration),
+    estimated_monthly_value_usd: Math.round(hours * 4.33 * 200),
+    confidence,
+    basis: [
+      `${blockerEvents} blocker event${blockerEvents === 1 ? "" : "s"} at 45 minutes of reconstruction/coordination each.`,
+      `${decisionEvents} decision event${decisionEvents === 1 ? "" : "s"} at 27 minutes of rediscovery/promotion each.`,
+      `${missedCount} missed orchestration signal${missedCount === 1 ? "" : "s"} at 39 minutes of manual writeback each.`,
+      `${coverage.missing.length} missing source${coverage.missing.length === 1 ? "" : "s"} reducing attribution confidence.`
+    ],
+    assumptions: [
+      "Uses a conservative $200/hour blended founder/operator cost for public-safe value estimates.",
+      "Acceleration estimates the execution lift from turning repeated evidence into automated attribution, decisions, and source connections.",
+      "Impact is directional until the user claims the fingerprint and confirms or corrects the evidence."
+    ]
+  };
+}
+function scoreExecutionQuality(input) {
+  const { coverage, findings, impact, patterns, recommendations, trails } = input;
+  const uniqueClients = sortedUnique(findings.map((finding) => finding.source_client));
+  const unknownCount = findings.filter((finding) => finding.source_client === "unknown").length;
+  const multiEventTrails = trails.filter((trail) => trail.events.length > 1).length;
+  const evidenceCoverage = clampScore2(
+    (coverage.coverage_score ?? 50) + Math.min(18, coverage.connected.length * 3) - coverage.missing.length * 4
+  );
+  const sourceAttribution = clampScore2(
+    34 + uniqueClients.filter((client) => client !== "unknown").length * 10 + (coverage.manifests?.filter((manifest) => manifest.status === "connected").length ?? 0) * 6 - unknownCount * 8
+  );
+  const trailDepth = clampScore2(
+    25 + (trails.length > 0 ? Math.round(multiEventTrails / trails.length * 45) : 0) + Math.min(20, trails.reduce((total, trail) => total + trail.events.length, 0) * 2)
+  );
+  const insightDepth = clampScore2(
+    30 + Math.min(28, patterns.length * 8) + Math.min(18, findings.filter((finding) => ["blocker", "decision", "outcome", "missed_orchestration_opportunity"].includes(finding.type)).length * 3)
+  );
+  const actionability = clampScore2(
+    30 + Math.min(35, recommendations.length * 10) + Math.min(20, recommendations.filter((recommendation) => recommendation.priority === "p0").length * 10)
+  );
+  const impactConfidence = clampScore2(impact.confidence * 100);
+  const overall = clampScore2(
+    evidenceCoverage * 0.22 + sourceAttribution * 0.18 + trailDepth * 0.18 + insightDepth * 0.18 + actionability * 0.14 + impactConfidence * 0.1
+  );
+  return {
+    overall,
+    evidence_coverage: evidenceCoverage,
+    source_attribution: sourceAttribution,
+    trail_depth: trailDepth,
+    insight_depth: insightDepth,
+    actionability,
+    impact_confidence: impactConfidence,
+    notes: [
+      "10/10 requires client-native extraction per source, multi-event chronology, source-specific evidence, and action recommendations tied to impact.",
+      multiEventTrails === trails.length ? "Every evidence path has multiple events." : `${trails.length - multiEventTrails} finding${trails.length - multiEventTrails === 1 ? "" : "s"} still need more chronology before they should be called recurring.`,
+      coverage.missing.length > 0 ? `Missing source coverage: ${coverage.missing.join(", ")}.` : "No required source gaps were declared for this run."
+    ]
+  };
+}
 function inferFinalState(findings) {
   if (findings.some((finding) => finding.type === "blocker")) return "blocked";
-  if (findings.some((finding) => finding.type === "artifact" || /\b(shipped|completed|done|verified)\b/i.test(finding.summary))) {
+  if (findings.some((finding) => finding.type === "artifact" || finding.type === "outcome" || /\b(shipped|completed|done|verified)\b/i.test(finding.summary))) {
     return "completed";
   }
   if (findings.some((finding) => finding.type === "action" || finding.type === "decision")) return "in_progress";
@@ -7534,6 +8152,8 @@ function entityTypeForFinding(finding) {
     case "goal":
     case "initiative_candidate":
       return "initiative";
+    case "outcome":
+      return "outcome";
     case "action":
       return /\b(outcome|shipped|completed|verified)\b/i.test(finding.summary) ? "outcome" : "task";
     case "missed_orchestration_opportunity":
@@ -7586,6 +8206,8 @@ function eventTypeForFinding(finding) {
     case "goal":
     case "initiative_candidate":
       return "initiative_created";
+    case "outcome":
+      return "outcome_recorded";
     case "action":
       return /\b(outcome|result|impact|roi)\b/i.test(finding.summary) ? "outcome_recorded" : "recommendation_generated";
     case "missed_orchestration_opportunity":
@@ -7596,7 +8218,7 @@ function trailStateForFindings(findings) {
   if (findings.some((finding) => finding.type === "blocker")) return "blocked";
   if (findings.some((finding) => finding.type === "missed_orchestration_opportunity")) return "missing_evidence";
   if (findings.some((finding) => /\b(contradict|conflict)\b/i.test(finding.summary))) return "contradicted";
-  if (findings.some((finding) => /\b(verified|proof|passed|complete_with_proof)\b/i.test(finding.summary))) return "verified";
+  if (findings.some((finding) => finding.type === "outcome" || /\b(verified|proof|passed|complete_with_proof)\b/i.test(finding.summary))) return "verified";
   if (findings.some((finding) => finding.type === "decision")) return "inferred";
   return "observed";
 }
@@ -7604,6 +8226,7 @@ function trailValenceForFindings(findings, recurrence) {
   if (findings.some((finding) => finding.type === "blocker")) return recurrence > 1 ? "escalating" : "risk";
   if (findings.some((finding) => finding.type === "missed_orchestration_opportunity")) return "leak";
   if (findings.some((finding) => finding.type === "decision") && recurrence > 1) return "wasteful_recurrence";
+  if (findings.some((finding) => finding.type === "outcome")) return "healthy";
   if (findings.some((finding) => finding.type === "business")) return "opportunity";
   if (findings.some((finding) => finding.type === "artifact")) return "healthy";
   return recurrence > 1 ? "useful_recurrence" : "opportunity";
@@ -7611,35 +8234,93 @@ function trailValenceForFindings(findings, recurrence) {
 function trailShapeForFindings(findings, recurrence) {
   const decisions = findings.filter((finding) => finding.type === "decision").length;
   const artifacts = findings.filter((finding) => finding.type === "artifact").length;
+  if (recurrence <= 1) return "single_signal";
   if (decisions > artifacts && decisions > 0) return "decision_heavy_artifact_light";
   if (artifacts > decisions && artifacts > 0 && decisions === 0) return "artifact_heavy_decision_light";
-  if (findings.some((finding) => finding.type === "blocker")) return "accelerating_issue";
+  if (findings.some((finding) => finding.type === "blocker")) return recurrence >= 3 ? "accelerating_issue" : "dense_recent_cluster";
   if (recurrence >= 3) return "chronic_recurrence";
   if (findings.some((finding) => /\b(resurface|again|back|revived|reappeared)\b/i.test(finding.summary))) return "zombie_revival";
-  if (findings.some((finding) => /\b(verified|passed|shipped|completed)\b/i.test(finding.summary))) return "healthy_execution";
+  if (findings.some((finding) => finding.type === "outcome" || /\b(verified|passed|shipped|completed)\b/i.test(finding.summary))) return "healthy_execution";
   return "dense_recent_cluster";
 }
+function findingTimestamp(finding, fallback) {
+  const occurredAt = finding.metadata.occurred_at;
+  return isIsoTimestamp(occurredAt) ? occurredAt : fallback;
+}
+function canonicalRelatedToken(finding) {
+  const candidates = [
+    ...arrayOfStrings(finding.metadata.related_source_ids),
+    ...arrayOfStrings(finding.metadata.related_entity_names),
+    finding.source_id,
+    finding.title
+  ];
+  const scored = candidates.map((candidate) => candidate.trim()).filter(Boolean).map((candidate) => {
+    const normalized = candidate.toLowerCase();
+    let score = 0;
+    if (/_/.test(candidate)) score += 6;
+    if (/orgx|mcp|wizard|plugin|runtime|hook|work graph|profile|trace|scaffold|ship|spawn|record|submit|list/i.test(candidate)) score += 5;
+    if (/session|jsonl|rollout|line|current-release/i.test(normalized)) score -= 4;
+    if (candidate.length > 80) score -= 2;
+    return { candidate, score };
+  }).filter((item) => item.score > 0).sort((left, right) => right.score - left.score);
+  return scored[0]?.candidate ?? null;
+}
+function groupingKeyForFinding(finding) {
+  const entityType = entityTypeForFinding(finding);
+  const token = canonicalRelatedToken(finding);
+  if (token && ["blocker", "source", "surface", "initiative", "outcome", "task"].includes(entityType)) {
+    return `${entityType}:${slugPart(token)}`;
+  }
+  return `${entityType}:${slugPart(finding.title)}`;
+}
+function trailTitleForGroup(entityType, group) {
+  const token = canonicalRelatedToken(group[0]);
+  if (group.length > 1 && token) {
+    const label = token.replace(/[-_]/g, " ").replace(/\b\w/g, (char) => char.toUpperCase());
+    if (entityType === "blocker") return `${label} is recurring as an execution blocker`;
+    if (entityType === "source") return `${label} is an attribution coverage gap`;
+    if (entityType === "surface") return `${label} is becoming a product surface evidence path`;
+    if (entityType === "outcome") return `${label} is becoming outcome evidence`;
+    return `${label} is becoming durable work`;
+  }
+  return group[0].title;
+}
+function trailSummaryForGroup(group) {
+  if (group.length === 1) return group[0].summary;
+  const sources = sortedUnique(group.map((finding) => labelForSourceClient(finding.source_client)));
+  const states = sortedUnique(
+    group.map((finding) => typeof finding.metadata.state === "string" ? finding.metadata.state : "").filter(Boolean)
+  );
+  return [
+    `${group.length} evidence events connect this finding across ${sources.join(", ")}.`,
+    states.length > 0 ? `Observed states: ${states.join(", ")}.` : "",
+    group[0]?.summary ?? ""
+  ].filter(Boolean).join(" ");
+}
 function buildWorkGraphTrails(findings, generatedAt) {
   const grouped = /* @__PURE__ */ new Map();
   for (const finding of findings) {
-    const entityType = entityTypeForFinding(finding);
-    const key = `${entityType}:${slugPart(finding.title)}`;
+    const key = groupingKeyForFinding(finding);
     grouped.set(key, [...grouped.get(key) ?? [], finding]);
   }
   return [...grouped.entries()].map(([key, group], index) => {
-    const first = group[0];
+    const sortedGroup = [...group].sort(
+      (left, right) => findingTimestamp(left, generatedAt).localeCompare(findingTimestamp(right, generatedAt))
+    );
+    const first = sortedGroup[0];
     const entityType = entityTypeForFinding(first);
     const entityId = `${entityType}:${shortHash(key, 12)}`;
-    const trailId = `trail:${shortHash({ key, evidence: group.map((finding) => finding.evidence_ref) }, 14)}`;
-    const recurrence = group.length;
-    const evidenceRefs = sortedUnique(group.map((finding) => finding.evidence_ref));
-    const events = group.map((finding, eventIndex) => ({
+    const trailId = `trail:${shortHash({ key, evidence: sortedGroup.map((finding) => finding.evidence_ref) }, 14)}`;
+    const recurrence = sortedGroup.length;
+    const evidenceRefs = sortedUnique(sortedGroup.map((finding) => finding.evidence_ref));
+    const events = sortedGroup.map((finding, eventIndex) => ({
       id: `${trailId}:event:${eventIndex + 1}`,
       trail_id: trailId,
       event_type: eventTypeForFinding(finding),
       entity_id: entityId,
       entity_type: entityType,
-      timestamp: generatedAt,
+      timestamp: findingTimestamp(finding, generatedAt),
+      ...typeof finding.metadata.actor_id === "string" ? { actor_id: finding.metadata.actor_id } : {},
       source_id: finding.source_id,
       source_type: finding.source_client,
       redacted_verbatim: finding.summary.slice(0, 320),
@@ -7656,28 +8337,30 @@ function buildWorkGraphTrails(findings, generatedAt) {
       confidence: Math.min(0.92, Math.max(0.58, event.confidence - 0.04)),
       evidence_refs: event.evidence_refs
     }));
-    const confidence = group.reduce((total, finding) => total + finding.confidence, 0) / group.length;
+    const confidence = sortedGroup.reduce((total, finding) => total + finding.confidence, 0) / sortedGroup.length;
+    const createdAt = events[0]?.timestamp ?? generatedAt;
+    const updatedAt = events[events.length - 1]?.timestamp ?? generatedAt;
     return {
       id: trailId,
       kind: trailKindForEntity(entityType),
-      title: first.title,
-      summary: first.summary,
+      title: trailTitleForGroup(entityType, sortedGroup),
+      summary: trailSummaryForGroup(sortedGroup),
       subject_entity_id: entityId,
       subject_entity_type: entityType,
-      state: trailStateForFindings(group),
-      valence: trailValenceForFindings(group, recurrence),
+      state: trailStateForFindings(sortedGroup),
+      valence: trailValenceForFindings(sortedGroup, recurrence),
       confidence: Number(confidence.toFixed(2)),
-      recurrence_score: Math.min(100, recurrence * 28 + evidenceRefs.length * 6),
+      recurrence_score: recurrence <= 1 ? Math.min(24, evidenceRefs.length * 8 + 10) : Math.min(100, recurrence * 24 + evidenceRefs.length * 7),
       impact_score: Math.min(100, Math.round(first.confidence * 70) + recurrence * 8 + (index < 4 ? 10 : 0)),
       privacy_state: "redacted",
       events,
       edges,
       evidence_refs: evidenceRefs,
-      blocker_ids: group.filter((finding) => finding.type === "blocker").map((finding) => finding.evidence_ref),
+      blocker_ids: sortedGroup.filter((finding) => finding.type === "blocker").map((finding) => finding.evidence_ref),
       recommendation_ids: [],
-      created_at: generatedAt,
-      updated_at: generatedAt,
-      shape: trailShapeForFindings(group, recurrence)
+      created_at: createdAt,
+      updated_at: updatedAt,
+      shape: trailShapeForFindings(sortedGroup, recurrence)
     };
   });
 }
@@ -7702,7 +8385,7 @@ function buildRecurringPatterns(coverage, findings, trails) {
     patterns.push({
       id: "pattern:trapped-decision",
       title: "Decisions are being made without durable OrgX writeback",
-      description: `${decisionTrails.length} decision trail${decisionTrails.length === 1 ? "" : "s"} appeared while no OrgX MCP write was detected.`,
+      description: `${decisionTrails.length} decision finding${decisionTrails.length === 1 ? "" : "s"} appeared while no OrgX MCP write was detected.`,
       pattern_type: "trapped_decision",
       affected_trail_ids: decisionTrails.map((trail) => trail.id),
       affected_entity_ids: decisionTrails.map((trail) => trail.subject_entity_id),
@@ -7718,7 +8401,7 @@ function buildRecurringPatterns(coverage, findings, trails) {
     patterns.push({
       id: "pattern:orphaned-artifact",
       title: "Artifacts do not have visible ownership",
-      description: `${artifactTrails.length} artifact trail${artifactTrails.length === 1 ? "" : "s"} appeared without a clear owner trail.`,
+      description: `${artifactTrails.length} artifact finding${artifactTrails.length === 1 ? "" : "s"} appeared without a clear owner-visible record.`,
       pattern_type: "orphaned_artifact",
       affected_trail_ids: artifactTrails.map((trail) => trail.id),
       affected_entity_ids: artifactTrails.map((trail) => trail.subject_entity_id),
@@ -7767,7 +8450,7 @@ function buildRecurringPatterns(coverage, findings, trails) {
     patterns.push({
       id: "pattern:repeated-work",
       title: "The same work shape is recurring",
-      description: `${highRecurrence.length} trail${highRecurrence.length === 1 ? "" : "s"} repeat strongly enough to deserve durable operating memory.`,
+      description: `${highRecurrence.length} finding${highRecurrence.length === 1 ? "" : "s"} repeat strongly enough to deserve durable operating memory.`,
       pattern_type: "repeated_work",
       affected_trail_ids: highRecurrence.map((trail) => trail.id),
       affected_entity_ids: highRecurrence.map((trail) => trail.subject_entity_id),
@@ -7783,7 +8466,7 @@ function buildRecurringPatterns(coverage, findings, trails) {
     patterns.push({
       id: "pattern:business-signal-unclaimed",
       title: "Business signal has not become a launchable initiative",
-      description: `${businessTrails.length} business trail${businessTrails.length === 1 ? "" : "s"} appeared without a matching initiative candidate.`,
+      description: `${businessTrails.length} business finding${businessTrails.length === 1 ? "" : "s"} appeared without a matching initiative candidate.`,
       pattern_type: "business_signal_unclaimed",
       affected_trail_ids: businessTrails.map((trail) => trail.id),
       affected_entity_ids: businessTrails.map((trail) => trail.subject_entity_id),
@@ -7796,10 +8479,13 @@ function buildRecurringPatterns(coverage, findings, trails) {
     });
   }
   if (blockerTrails.length > 0) {
+    const topBlockerTrail = [...blockerTrails].sort(
+      (left, right) => right.events.length - left.events.length || right.impact_score - left.impact_score
+    )[0];
     patterns.push({
       id: "pattern:handoff-friction",
-      title: "Blockers are becoming handoff friction",
-      description: `${blockerTrails.length} blocker trail${blockerTrails.length === 1 ? "" : "s"} need owner-visible resolution.`,
+      title: topBlockerTrail && topBlockerTrail.events.length > 1 ? `${topBlockerTrail.title} and needs owner-visible resolution` : "Blockers are becoming handoff friction",
+      description: `${blockerTrails.length} blocker finding${blockerTrails.length === 1 ? "" : "s"} need owner-visible resolution.`,
       pattern_type: "handoff_friction",
       affected_trail_ids: blockerTrails.map((trail) => trail.id),
       affected_entity_ids: blockerTrails.map((trail) => trail.subject_entity_id),
@@ -7852,7 +8538,7 @@ function buildTrailRecommendations(patterns, trails) {
       add({
         id: "recommendation:connect-source",
         title: "Connect missing source coverage",
-        summary: "Close the evidence gap by connecting the coordination or proof sources where trails terminate.",
+        summary: "Close the evidence gap by connecting the coordination or proof sources where findings lose ownership or verification context.",
         action_type: "connect_source",
         trail_ids: pattern.affected_trail_ids,
         evidence_refs: evidenceRefs,
@@ -7872,10 +8558,22 @@ function buildTrailRecommendations(patterns, trails) {
         expected_lift: "+continuous attribution",
         confidence: pattern.confidence
       });
+    } else if (pattern.pattern_type === "handoff_friction") {
+      add({
+        id: "recommendation:resolve-blocker-handoff",
+        title: "Resolve the blocker handoff",
+        summary: "Promote the recurring blocker path into assigned work with proof requirements and a clear owner.",
+        action_type: "assign_owner",
+        trail_ids: pattern.affected_trail_ids,
+        evidence_refs: evidenceRefs,
+        priority: pattern.severity === "critical" || pattern.severity === "high" ? "p0" : "p1",
+        expected_lift: "+execution continuity",
+        confidence: pattern.confidence
+      });
     } else if (pattern.pattern_type === "business_signal_unclaimed" || pattern.pattern_type === "repeated_work") {
       add({
         id: "recommendation:launch-initiative",
-        title: "Launch from this trail",
+        title: "Launch from this evidence",
         summary: "Convert the highest-recurring evidence path into an OrgX initiative with proof requirements.",
         action_type: "launch_initiative",
         trail_ids: pattern.affected_trail_ids,
@@ -7890,7 +8588,7 @@ function buildTrailRecommendations(patterns, trails) {
     const topTrail = [...trails].sort((a, b) => b.impact_score - a.impact_score)[0];
     add({
       id: "recommendation:inspect-top-trail",
-      title: "Inspect the strongest trail",
+      title: "Inspect the strongest finding",
       summary: "Review the highest-confidence evidence path and decide whether it should become durable OrgX memory.",
       action_type: "launch_initiative",
       trail_ids: [topTrail.id],
@@ -7900,44 +8598,64 @@ function buildTrailRecommendations(patterns, trails) {
       confidence: topTrail.confidence
     });
   }
-  return recommendations.slice(0, 5);
+  const priorityRank = { p0: 0, p1: 1, p2: 2 };
+  return recommendations.sort(
+    (left, right) => priorityRank[left.priority] - priorityRank[right.priority] || right.confidence - left.confidence
+  ).slice(0, 5);
 }
 function buildWorkGraphMirror(input) {
-  const { coverage, generatedAt, patterns, recommendations, trails } = input;
-  const topTrail = [...trails].sort((a, b) => b.impact_score - a.impact_score)[0];
+  const { auditMethod, coverage, domains = [], generatedAt, impact, patterns, recommendations, skillToolSignals = [], trails } = input;
+  const topTrail = selectPublicTopTrail(trails);
   const topPattern = [...patterns].sort((a, b) => b.recurrence_count - a.recurrence_count)[0];
   const decisionCount = trailsForType(trails, "decision").length;
   const artifactCount = trailsForType(trails, "artifact").length;
   const blockerCount = trailsForType(trails, "blocker").length;
   const sourceGapCount = coverage.missing.length;
-  const headline = topPattern ? topPattern.title : topTrail ? `${topTrail.title} is the clearest work trail` : "Your work is leaving an operating trail";
+  const sourceClients = sortedUnique(
+    trails.flatMap((trail) => trail.events.map((event) => event.source_type))
+  );
+  const sourcePhrase = sourceClients.length > 0 ? sourceClients.map(labelForSourceClient).join(", ") : coverage.connected.join(", ") || "local sources";
+  const headline = blockerCount > 0 ? "Your AI work is shipping, but the execution record is incomplete" : sourceGapCount > 0 ? "Your AI work is visible, but the proof chain is incomplete" : topPattern ? "Your work has a recurring operating pattern worth preserving" : topTrail ? "Your work is becoming an operating profile" : "Your work is leaving evidence OrgX can organize";
+  const domainPhrase = domains.length > 0 ? domains.slice(0, 4).map((domain) => domain.label).join(", ") : "the connected work surface";
+  const toolPhrase = skillToolSignals.length > 0 ? skillToolSignals.slice(0, 4).map((signal) => signal.label).join(", ") : "client sessions and available tools";
   const primaryClaimRefs = topTrail?.evidence_refs ?? [];
   const claims = [
     {
       id: "mirror:trail-count",
-      text: `${trails.length} trails were detected across ${coverage.connected.length} connected source${coverage.connected.length === 1 ? "" : "s"}.`,
+      text: `${trails.length} evidence-backed finding${trails.length === 1 ? "" : "s"} were detected across ${coverage.connected.length} connected source${coverage.connected.length === 1 ? "" : "s"}.`,
       evidence_refs: trails.flatMap((trail) => trail.evidence_refs).slice(0, 6),
       confidence: trails.length > 0 ? 0.82 : 0.55
     },
     {
       id: "mirror:decision-artifact-balance",
-      text: `${decisionCount} decision trail${decisionCount === 1 ? "" : "s"} and ${artifactCount} artifact trail${artifactCount === 1 ? "" : "s"} were found.`,
+      text: `${decisionCount} decision finding${decisionCount === 1 ? "" : "s"} and ${artifactCount} artifact finding${artifactCount === 1 ? "" : "s"} were found.`,
       evidence_refs: trails.filter((trail) => trail.subject_entity_type === "decision" || trail.subject_entity_type === "artifact").flatMap((trail) => trail.evidence_refs).slice(0, 6),
       confidence: 0.78
     },
     {
       id: "mirror:missing-sources",
-      text: sourceGapCount > 0 ? `${sourceGapCount} source gap${sourceGapCount === 1 ? "" : "s"} still limit attribution depth.` : "The connected sources are enough for a first operating profile.",
+      text: sourceGapCount > 0 ? `${sourceGapCount} source gap${sourceGapCount === 1 ? "" : "s"} still limit attribution depth.` : "The connected sources are enough for a first operating profile, pending human review.",
       evidence_refs: trailsForType(trails, "source").flatMap((trail) => trail.evidence_refs).slice(0, 4),
       confidence: sourceGapCount > 0 ? 0.76 : 0.66
-    }
+    },
+    ...impact ? [{
+      id: "mirror:impact",
+      text: `${impact.time_saved_hours_per_week} hours/week and +${impact.acceleration_percent}% execution acceleration are recoverable if the top findings get owner, proof, and writeback.`,
+      evidence_refs: trails.flatMap((trail) => trail.evidence_refs).slice(0, 6),
+      confidence: impact.confidence
+    }] : []
   ];
+  const searchClaim = auditMethod ? `OrgX searched ${auditMethod.searched_session_files} AI-client session files and ${auditMethod.searched_message_count} message turns across ${sourcePhrase}; it retained ${auditMethod.retained_evidence_lines} evidence lines and excluded raw transcripts.` : `OrgX searched your AI-client session evidence across ${sourcePhrase} without requiring OrgX tool calls to be present.`;
+  const topIssue = topTrail ? `The highest-risk issue is ${topTrail.title.toLowerCase()}.` : topPattern ? `The highest-risk pattern is ${topPattern.title.toLowerCase()}.` : "The first profile is forming from sparse evidence and should be reviewed before promotion.";
   const body = [
-    `OrgX found ${trails.length} evidence trail${trails.length === 1 ? "" : "s"} across ${coverage.connected.join(", ") || "local sources"}.`,
-    `The strongest signal is ${topPattern ? topPattern.title.toLowerCase() : topTrail?.title ?? "still forming"}.`,
-    blockerCount > 0 ? `${blockerCount} blocker trail${blockerCount === 1 ? "" : "s"} need promotion into owner-visible work.` : "The healthiest trails already connect evidence to action.",
-    recommendations[0] ? `The next durable move is: ${recommendations[0].title}.` : "The next move is to inspect the highest-confidence trail before publishing it."
-  ].join(" ");
+    searchClaim,
+    `It found ${trails.length} evidence-backed finding${trails.length === 1 ? "" : "s"} across ${domainPhrase}, with ${toolPhrase} showing up as the strongest skills, tools, or sources.`,
+    topIssue,
+    blockerCount > 0 ? `${blockerCount} blocker finding${blockerCount === 1 ? "" : "s"} show work returning as new work instead of becoming owner-visible resolution.` : `${decisionCount} decision finding${decisionCount === 1 ? "" : "s"} and ${artifactCount} artifact finding${artifactCount === 1 ? "" : "s"} show where work can become durable.`,
+    sourceGapCount > 0 ? `${sourceGapCount} source gap${sourceGapCount === 1 ? "" : "s"} still limit trust: ownership, handoffs, GitHub proof, Slack coordination, or later verification.` : "The connected sources are enough for a first public-safe profile, pending human review.",
+    impact ? `Left unresolved, the profile estimates ${impact.time_saved_hours_per_week} recoverable hours/week and about $${impact.estimated_monthly_value_usd.toLocaleString("en-US")}/month in operator leverage.` : "",
+    recommendations[0] ? `The next repair is concrete: ${recommendations[0].title}.` : "The next move is to inspect the highest-confidence finding before publishing it."
+  ].filter(Boolean).join(" ");
   return {
     headline,
     body,
@@ -7947,14 +8665,58 @@ function buildWorkGraphMirror(input) {
     generated_at: generatedAt
   };
 }
+function selectPublicTopTrail(trails) {
+  const ranked = [...trails].sort((left, right) => publicTrailRank(right) - publicTrailRank(left));
+  return ranked[0];
+}
+function publicTrailRank(trail) {
+  const title = trail.title.trim();
+  let score = trail.impact_score;
+  if (trail.events.length > 1) score += 10;
+  if (trail.subject_entity_type === "blocker") score += 6;
+  if (/\b(?:scaffold|ship_batch|mcp__orgx__list_entities|list entities|schema validation|route behavior|dispatching agent runs|operation qa loop)\b/i.test(title)) {
+    score += 14;
+  }
+  if (/^(?:[-*✓{`'"]|\d+[,.]?$)/.test(title)) score -= 32;
+  if (/[{}|;]/.test(title)) score -= 28;
+  if (title.length < 22) score -= 26;
+  if (/^(?:result|summary)\s*:/i.test(title)) score -= 18;
+  return score;
+}
 function buildTensionMetrics(input) {
-  const { coverage, patterns, trails } = input;
+  const { coverage, impact, patterns, quality, trails } = input;
   const decisionTrails = trailsForType(trails, "decision");
   const blockerTrails = trailsForType(trails, "blocker");
   const artifactTrails = trailsForType(trails, "artifact");
   const missingSourceTrails = trailsForType(trails, "source");
   const topReady = trails.filter((trail) => trail.impact_score >= 70 && trail.confidence >= 0.75);
   return [
+    ...quality ? [{
+      id: "tension:quality-score",
+      label: "quality score",
+      value: `${quality.overall}/100`,
+      tone: quality.overall >= 82 ? "good" : quality.overall >= 65 ? "warning" : "danger",
+      trail_ids: trails.slice(0, 8).map((trail) => trail.id),
+      evidence_refs: trails.flatMap((trail) => trail.evidence_refs).slice(0, 8),
+      explanation: "Weighted audit quality across evidence coverage, attribution, chronology depth, insight depth, actionability, and impact confidence."
+    }] : [],
+    ...impact ? [{
+      id: "tension:time-saved",
+      label: "hours recoverable",
+      value: `${impact.time_saved_hours_per_week}h/wk`,
+      tone: impact.time_saved_hours_per_week >= 4 ? "warning" : "muted",
+      trail_ids: patterns.flatMap((pattern) => pattern.affected_trail_ids).slice(0, 8),
+      evidence_refs: trails.flatMap((trail) => trail.evidence_refs).slice(0, 8),
+      explanation: "Estimated time recovered by promoting repeated decisions, blockers, artifacts, and writeback gaps into durable operating memory."
+    }, {
+      id: "tension:acceleration",
+      label: "acceleration",
+      value: `+${impact.acceleration_percent}%`,
+      tone: impact.acceleration_percent >= 30 ? "good" : "muted",
+      trail_ids: patterns.flatMap((pattern) => pattern.affected_trail_ids).slice(0, 8),
+      evidence_refs: trails.flatMap((trail) => trail.evidence_refs).slice(0, 8),
+      explanation: "Directional execution lift from connecting source evidence, writeback, owners, and action recommendations."
+    }] : [],
     {
       id: "tension:work-leaks",
       label: "work leaks",
@@ -7971,7 +8733,7 @@ function buildTensionMetrics(input) {
       tone: decisionTrails.length > 0 && !coverage.orgxMcpCalled ? "danger" : "muted",
       trail_ids: decisionTrails.map((trail) => trail.id),
       evidence_refs: decisionTrails.flatMap((trail) => trail.evidence_refs).slice(0, 8),
-      explanation: "Decision trails that have not been promoted into durable OrgX records."
+      explanation: "Decision evidence that has not been promoted into durable OrgX records."
     },
     {
       id: "tension:artifacts-orphaned",
@@ -7998,7 +8760,7 @@ function buildTensionMetrics(input) {
       tone: topReady.length > 0 && blockerTrails.length === 0 ? "good" : "muted",
       trail_ids: topReady.map((trail) => trail.id).slice(0, 6),
       evidence_refs: topReady.flatMap((trail) => trail.evidence_refs).slice(0, 8),
-      explanation: "High-confidence trails that can become initiatives, decisions, artifacts, or owner-visible follow-ups."
+      explanation: "High-confidence findings that can become initiatives, decisions, artifacts, or owner-visible follow-ups."
     }
   ];
 }
@@ -8011,6 +8773,317 @@ function countFindingsByType(findings) {
     Object.entries(counts).sort(([left], [right]) => left.localeCompare(right))
   );
 }
+function isIsoTimestamp(value) {
+  return typeof value === "string" && !Number.isNaN(Date.parse(value));
+}
+function redactionStateForFinding(finding) {
+  const privacy = typeof finding.metadata.privacy_state === "string" ? finding.metadata.privacy_state : "";
+  if (privacy === "private") return "private";
+  if (privacy === "redacted") return "redacted";
+  return "public_summary";
+}
+function attributionKindForFinding(type) {
+  switch (type) {
+    case "action":
+    case "blocker":
+    case "outcome":
+      return "action";
+    case "decision":
+    case "artifact":
+    case "person":
+    case "business":
+    case "product_surface":
+    case "goal":
+      return type;
+    case "initiative_candidate":
+      return "goal";
+    case "missed_orchestration_opportunity":
+      return "source";
+    default:
+      return null;
+  }
+}
+function attributionEventTypeForFinding(finding) {
+  if (finding.source_client === "slack") return "slack_message";
+  if (finding.source_client === "github") return "github_event";
+  if (finding.source_client === "linear") return "linear_event";
+  if (finding.source_client === "gmail") return "gmail_message";
+  if (finding.source_client === "calendar") return "calendar_event";
+  if (finding.source_client === "notion" || finding.source_client === "docs") return "doc_signal";
+  if (finding.source_client === "mcp") return "mcp_call";
+  if (finding.type === "artifact") return "repo_artifact";
+  if (finding.type === "missed_orchestration_opportunity") return "source_coverage";
+  if (/\b(mcp|tool|hook|runtime)\b/i.test(`${finding.title} ${finding.summary}`)) return "tool_signal";
+  return "client_extraction";
+}
+function nodeBucketForKind(kind) {
+  switch (kind) {
+    case "decision":
+      return "decisions";
+    case "artifact":
+      return "artifacts";
+    case "person":
+      return "people";
+    case "agent":
+      return "agents";
+    case "tool":
+      return "tools";
+    case "business":
+      return "businesses";
+    case "product_surface":
+      return "product_surfaces";
+    case "goal":
+      return "goals";
+    case "source":
+      return "sources";
+    case "action":
+    default:
+      return "actions";
+  }
+}
+function nodeIdForFinding(kind, finding) {
+  const dedupeSource = finding.metadata.dedupe_key ?? finding.evidence_ref ?? finding.title;
+  return `${kind}:${slugPart(finding.title)}:${shortHash(dedupeSource, 8)}`;
+}
+function buildFindingNode(finding, kind) {
+  const id = nodeIdForFinding(kind, finding);
+  return {
+    id,
+    kind,
+    label: finding.title,
+    summary: finding.summary,
+    source_client: finding.source_client,
+    evidence_refs: [finding.evidence_ref],
+    linked_node_ids: [],
+    confidence: finding.confidence,
+    weight: clampScore2(finding.confidence * 100),
+    review_state: "unreviewed",
+    dedupe_key: `${kind}:${slugPart(finding.title)}`,
+    metadata: {
+      source_id: finding.source_id,
+      finding_type: finding.type,
+      ...finding.metadata
+    }
+  };
+}
+function mergeNodes(nodes) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    const key = node.dedupe_key ?? node.id;
+    const previous = merged.get(key);
+    if (!previous) {
+      merged.set(key, node);
+      continue;
+    }
+    merged.set(key, {
+      ...previous,
+      confidence: Math.max(previous.confidence, node.confidence),
+      evidence_refs: sortedUnique([...previous.evidence_refs, ...node.evidence_refs]),
+      linked_node_ids: sortedUnique([...previous.linked_node_ids, ...node.linked_node_ids]),
+      weight: Math.max(previous.weight, node.weight)
+    });
+  }
+  return [...merged.values()].sort((left, right) => right.weight - left.weight);
+}
+function sourceNode(source, connected) {
+  const label = source.trim() || "Unknown source";
+  return {
+    id: `source:${slugPart(label)}:${connected ? "connected" : "missing"}`,
+    kind: "source",
+    label,
+    summary: connected ? `${label} contributed evidence to this Work Graph.` : `${label} was not connected, so related attribution remains incomplete.`,
+    evidence_refs: [],
+    linked_node_ids: [],
+    confidence: connected ? 0.8 : 0.52,
+    weight: connected ? 70 : 62,
+    review_state: connected ? "unreviewed" : "important",
+    dedupe_key: `source:${slugPart(label)}`,
+    metadata: { connected }
+  };
+}
+function buildToolNodes(coverage, findings) {
+  const mentionsOrgxTool = coverage.mcpObserved || findings.some((finding) => /\b(orgx[_-]?mcp|orgx_emit|mcp__orgx|tool call)\b/i.test(`${finding.title} ${finding.summary}`));
+  if (!mentionsOrgxTool) return [];
+  return [
+    {
+      id: "tool:orgx-mcp",
+      kind: "tool",
+      label: "OrgX MCP",
+      summary: coverage.orgxMcpCalled ? "OrgX MCP was observed as a durable writeback surface in the audited work." : "OrgX MCP was available or mentioned, but the audit found incomplete durable writeback.",
+      source_client: "mcp",
+      evidence_refs: findings.filter((finding) => /\b(orgx|mcp|tool)\b/i.test(`${finding.title} ${finding.summary}`)).map((finding) => finding.evidence_ref).slice(0, 12),
+      linked_node_ids: [],
+      confidence: coverage.orgxMcpCalled ? 0.86 : 0.72,
+      weight: coverage.orgxMcpCalled ? 88 : 76,
+      review_state: "unreviewed",
+      dedupe_key: "tool:orgx-mcp",
+      metadata: {
+        mcp_observed: coverage.mcpObserved,
+        orgx_observed: coverage.orgxObserved,
+        orgx_mcp_called: coverage.orgxMcpCalled,
+        skill_only_signal: coverage.skillOnlySignal
+      }
+    }
+  ];
+}
+function buildAgentNodes(findings) {
+  const actorIds = sortedUnique(
+    findings.map((finding) => typeof finding.metadata.actor_id === "string" ? finding.metadata.actor_id.trim() : "").filter(Boolean)
+  );
+  const sourceAgents = sortedUnique(
+    findings.map(
+      (finding) => ["codex", "claude", "claude-code", "cursor", "openclaw"].includes(finding.source_client) ? finding.source_client : ""
+    ).filter(Boolean)
+  );
+  return [...actorIds, ...sourceAgents].slice(0, 20).map((agent) => ({
+    id: `agent:${slugPart(agent)}`,
+    kind: "agent",
+    label: agent,
+    summary: `${agent} contributed evidence to the Work Graph audit.`,
+    source_client: sourceAgents.includes(agent) ? agent : "manual",
+    evidence_refs: findings.filter((finding) => finding.metadata.actor_id === agent || finding.source_client === agent).map((finding) => finding.evidence_ref).slice(0, 12),
+    linked_node_ids: [],
+    confidence: 0.72,
+    weight: 64,
+    review_state: "unreviewed",
+    dedupe_key: `agent:${slugPart(agent)}`,
+    metadata: {}
+  }));
+}
+function buildWorkGraphAttributionSpine(input) {
+  const evidence_refs = input.findings.map((finding) => ({
+    id: finding.evidence_ref,
+    source_client: finding.source_client,
+    source_id: finding.source_id,
+    label: finding.title,
+    summary: finding.summary.slice(0, 1200),
+    ...isIsoTimestamp(finding.metadata.occurred_at) ? { occurred_at: finding.metadata.occurred_at } : {},
+    confidence: finding.confidence,
+    redaction_state: redactionStateForFinding(finding),
+    metadata: {
+      raw_transcript_sent: false,
+      source_label: finding.metadata.source_label ?? null
+    }
+  }));
+  const source_events = [
+    ...input.events.map((event) => ({
+      source_client: event.source_client,
+      source_id: event.source_id,
+      source_label: event.source_label,
+      event_type: event.event_type === "client_extraction" ? "client_extraction" : event.event_type,
+      evidence_ref: event.evidence_ref,
+      confidence: 0.7,
+      metadata: {
+        ...event.metadata,
+        raw_transcript_sent: false
+      }
+    })),
+    ...input.findings.map((finding) => ({
+      source_client: finding.source_client,
+      source_id: finding.source_id,
+      source_label: typeof finding.metadata.source_label === "string" ? finding.metadata.source_label : finding.source_id,
+      event_type: attributionEventTypeForFinding(finding),
+      ...isIsoTimestamp(finding.metadata.occurred_at) ? { occurred_at: finding.metadata.occurred_at } : {},
+      evidence_ref: finding.evidence_ref,
+      ...typeof finding.metadata.actor_id === "string" ? { actor_ref: finding.metadata.actor_id } : {},
+      confidence: finding.confidence,
+      metadata: {
+        finding_type: finding.type,
+        raw_transcript_sent: false
+      }
+    }))
+  ];
+  const buckets = {
+    actions: [],
+    decisions: [],
+    artifacts: [],
+    people: [],
+    agents: buildAgentNodes(input.findings),
+    tools: buildToolNodes(input.coverage, input.findings),
+    businesses: [],
+    product_surfaces: [],
+    goals: [],
+    sources: [
+      ...input.coverage.connected.map((source) => sourceNode(source, true)),
+      ...input.coverage.missing.map((source) => sourceNode(source, false))
+    ],
+    initiative_candidates: []
+  };
+  for (const finding of input.findings) {
+    const kind = attributionKindForFinding(finding.type);
+    if (!kind) continue;
+    const node = buildFindingNode(finding, kind);
+    const bucket = finding.type === "initiative_candidate" ? "initiative_candidates" : nodeBucketForKind(kind);
+    buckets[bucket].push(node);
+  }
+  const normalized = {
+    source_events: source_events.filter(
+      (event, index, all) => all.findIndex(
+        (candidate) => [
+          candidate.source_client,
+          candidate.source_id,
+          candidate.event_type,
+          candidate.evidence_ref
+        ].join(":") === [
+          event.source_client,
+          event.source_id,
+          event.event_type,
+          event.evidence_ref
+        ].join(":")
+      ) === index
+    ).slice(0, 1e3),
+    actions: mergeNodes(buckets.actions).slice(0, 500),
+    decisions: mergeNodes(buckets.decisions).slice(0, 500),
+    artifacts: mergeNodes(buckets.artifacts).slice(0, 500),
+    people: mergeNodes(buckets.people).slice(0, 500),
+    agents: mergeNodes(buckets.agents).slice(0, 200),
+    tools: mergeNodes(buckets.tools).slice(0, 300),
+    businesses: mergeNodes(buckets.businesses).slice(0, 200),
+    product_surfaces: mergeNodes(buckets.product_surfaces).slice(0, 500),
+    goals: mergeNodes(buckets.goals).slice(0, 500),
+    sources: mergeNodes(buckets.sources).slice(0, 300),
+    initiative_candidates: mergeNodes(buckets.initiative_candidates).slice(0, 50),
+    evidence_refs: mergeByEvidenceId(evidence_refs).slice(0, 1e3)
+  };
+  const nodeCount = normalized.actions.length + normalized.decisions.length + normalized.artifacts.length + normalized.people.length + normalized.agents.length + normalized.tools.length + normalized.businesses.length + normalized.product_surfaces.length + normalized.goals.length + normalized.sources.length + normalized.initiative_candidates.length;
+  const confidenceInputs = [
+    ...normalized.evidence_refs.map((evidence) => evidence.confidence),
+    ...normalized.source_events.map((event) => event.confidence)
+  ];
+  const confidence = confidenceInputs.length ? Number((confidenceInputs.reduce((total, value) => total + value, 0) / confidenceInputs.length).toFixed(2)) : 0;
+  return {
+    ...normalized,
+    confidence,
+    dedupe_keys: sortedUnique([
+      ...Object.values(normalized).flat().map((item) => typeof item === "object" && item && "dedupe_key" in item ? String(item.dedupe_key ?? "") : "").filter(Boolean)
+    ]).slice(0, 1e3),
+    privacy: {
+      redaction_state: "public_summary",
+      raw_transcripts_included: false,
+      public_summary_only: true
+    },
+    review: {
+      pending_count: nodeCount,
+      correction_affordances: [
+        "confirm",
+        "merge",
+        "hide",
+        "mark_important",
+        "launch_or_dismiss"
+      ]
+    }
+  };
+}
+function mergeByEvidenceId(evidenceRefs) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const evidence of evidenceRefs) {
+    const previous = merged.get(evidence.id);
+    if (!previous || evidence.confidence > previous.confidence) {
+      merged.set(evidence.id, evidence);
+    }
+  }
+  return [...merged.values()].sort((left, right) => right.confidence - left.confidence);
+}
 function buildWorkGraphFingerprint(input) {
   const sourceClients = sortedUnique(input.findings.map((finding) => finding.source_client));
   const patternHashes = input.findings.map(
@@ -8088,6 +9161,7 @@ function buildSessionReconciliationReport(input) {
     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 extractionProtocol = buildWorkGraphExtractionProtocol();
   const clientExtractionSummaries = summarizeClientExtractions(clientExtractions);
   const connectedSources = sortedUnique([
     ...input.connectedSources ?? input.imports.map((source) => source.sourceLabel),
@@ -8103,23 +9177,56 @@ function buildSessionReconciliationReport(input) {
     (finding, index, all) => all.findIndex((candidate) => candidate.evidence_ref === finding.evidence_ref) === index
   );
   const allFindings = [...findings, ...autoMissed];
+  const auditMethod = buildAuditMethod({
+    clientExtractions,
+    extractionProtocol,
+    imports: input.imports
+  });
+  const domainCoverage = buildDomainCoverage(allFindings);
+  const skillToolSignals = buildSkillToolSignals(allFindings);
   const trails = buildWorkGraphTrails(allFindings, generatedAt);
   const recurringPatterns = buildRecurringPatterns(coverage, allFindings, trails);
   const opportunityScore = scoreOpportunity(coverage, allFindings);
   const initiativeKickoffs = buildKickoffs(allFindings, missed, opportunityScore);
   const recommendations = buildTrailRecommendations(recurringPatterns, trails);
+  const impactProjection = estimateImpactProjection({
+    coverage,
+    findings: allFindings,
+    opportunityScore,
+    patterns: recurringPatterns,
+    trails
+  });
+  const executionQuality = scoreExecutionQuality({
+    coverage,
+    findings: allFindings,
+    impact: impactProjection,
+    patterns: recurringPatterns,
+    recommendations,
+    trails
+  });
   const mirror = buildWorkGraphMirror({
+    auditMethod,
     coverage,
+    domains: domainCoverage,
     generatedAt,
+    impact: impactProjection,
     patterns: recurringPatterns,
     recommendations,
+    skillToolSignals,
     trails
   });
   const tensionMetrics = buildTensionMetrics({
     coverage,
+    impact: impactProjection,
     patterns: recurringPatterns,
+    quality: executionQuality,
     trails
   });
+  const attributionSpine = buildWorkGraphAttributionSpine({
+    coverage,
+    events,
+    findings: allFindings
+  });
   const fingerprint = buildWorkGraphFingerprint({
     connectedSources,
     findings: allFindings,
@@ -8155,8 +9262,11 @@ function buildSessionReconciliationReport(input) {
     source_client: "wizard",
     session_id: sessionId,
     workspace: input.workspace,
-    extraction_protocol: buildWorkGraphExtractionProtocol(),
+    extraction_protocol: extractionProtocol,
+    audit_method: auditMethod,
     client_extractions: clientExtractionSummaries,
+    domain_coverage: domainCoverage,
+    skill_tool_signals: skillToolSignals,
     source_coverage: coverage,
     final_state: inferFinalState(allFindings),
     events,
@@ -8167,7 +9277,10 @@ function buildSessionReconciliationReport(input) {
     recommendations,
     mirror,
     tension_metrics: tensionMetrics,
+    attribution_spine: attributionSpine,
     opportunity_score: opportunityScore,
+    execution_quality: executionQuality,
+    impact_projection: impactProjection,
     initiative_kickoffs: initiativeKickoffs,
     redaction_level: "summary_only",
     raw_transcripts_sent: false
@@ -8234,6 +9347,18 @@ function renderWorkGraphMarkdown(report) {
     lines.push(`- ${lens.lens}: ${lens.return_when}`);
   }
   lines.push("");
+  lines.push("## Audit Method");
+  lines.push("");
+  lines.push(`Mode: ${report.audit_method.mode}`);
+  lines.push(`Session files searched: ${report.audit_method.searched_session_files}`);
+  lines.push(`Message turns searched: ${report.audit_method.searched_message_count}`);
+  lines.push(`Evidence lines retained: ${report.audit_method.retained_evidence_lines}`);
+  lines.push(`Source groups searched: ${report.audit_method.searched_source_groups}`);
+  lines.push(`Extraction lenses: ${report.audit_method.extraction_lenses.join(", ")}`);
+  for (const note of report.audit_method.notes) {
+    lines.push(`- ${note}`);
+  }
+  lines.push("");
   lines.push("## Client Extractions");
   lines.push("");
   if (report.client_extractions.length === 0) {
@@ -8244,6 +9369,26 @@ function renderWorkGraphMarkdown(report) {
     }
   }
   lines.push("");
+  lines.push("## Domain Coverage");
+  lines.push("");
+  if (report.domain_coverage.length === 0) {
+    lines.push("- No domain clusters reached the public-summary threshold.");
+  } else {
+    for (const domain of report.domain_coverage) {
+      lines.push(`- ${domain.label}: ${domain.finding_count} findings across ${domain.source_clients.join(", ")}. ${domain.summary}`);
+    }
+  }
+  lines.push("");
+  lines.push("## Skills, Agents, Tools, and Sources");
+  lines.push("");
+  if (report.skill_tool_signals.length === 0) {
+    lines.push("- No repeated skill/tool signals reached the public-summary threshold.");
+  } else {
+    for (const signal of report.skill_tool_signals) {
+      lines.push(`- [${signal.kind}] ${signal.label}: ${signal.mention_count} mention${signal.mention_count === 1 ? "" : "s"} across ${signal.source_clients.join(", ")}.`);
+    }
+  }
+  lines.push("");
   lines.push("## Opportunity Score");
   lines.push("");
   lines.push(`Overall: ${report.opportunity_score.overall}/100`);
@@ -8254,15 +9399,46 @@ function renderWorkGraphMarkdown(report) {
   lines.push(`Automation potential: ${report.opportunity_score.automation_potential}/100`);
   lines.push(`OrgX fit: ${report.opportunity_score.orgx_fit}/100`);
   lines.push("");
+  lines.push("## Execution Quality");
+  lines.push("");
+  lines.push(`Overall: ${report.execution_quality.overall}/100`);
+  lines.push(`Evidence coverage: ${report.execution_quality.evidence_coverage}/100`);
+  lines.push(`Source attribution: ${report.execution_quality.source_attribution}/100`);
+  lines.push(`Chronology depth: ${report.execution_quality.trail_depth}/100`);
+  lines.push(`Insight depth: ${report.execution_quality.insight_depth}/100`);
+  lines.push(`Actionability: ${report.execution_quality.actionability}/100`);
+  lines.push(`Impact confidence: ${report.execution_quality.impact_confidence}/100`);
+  for (const note of report.execution_quality.notes) {
+    lines.push(`- ${note}`);
+  }
+  lines.push("");
+  lines.push("## Impact Projection");
+  lines.push("");
+  lines.push(`Time saved: ${report.impact_projection.time_saved_hours_per_week}h/week`);
+  lines.push(`Acceleration: +${report.impact_projection.acceleration_percent}%`);
+  lines.push(`Estimated monthly value: $${report.impact_projection.estimated_monthly_value_usd.toLocaleString("en-US")}`);
+  lines.push(`Confidence: ${report.impact_projection.confidence}`);
+  for (const item of report.impact_projection.basis) {
+    lines.push(`- ${item}`);
+  }
+  lines.push("");
   lines.push("## Source Coverage");
   lines.push("");
   lines.push(`Connected: ${report.source_coverage.connected.join(", ") || "none"}`);
   lines.push(`Missing: ${report.source_coverage.missing.join(", ") || "none"}`);
+  lines.push(`Coverage score: ${report.source_coverage.coverage_score ?? 0}/100`);
   lines.push(`MCP observed: ${report.source_coverage.mcpObserved ? "yes" : "no"}`);
   lines.push(`OrgX observed: ${report.source_coverage.orgxObserved ? "yes" : "no"}`);
   lines.push(`OrgX MCP called: ${report.source_coverage.orgxMcpCalled ? "yes" : "no"}`);
+  if (report.source_coverage.manifests?.length) {
+    lines.push("");
+    lines.push("Source manifests:");
+    for (const manifest of report.source_coverage.manifests) {
+      lines.push(`- [${manifest.status}] ${manifest.source_label}: ${manifest.finding_count} findings, ${manifest.searched_session_count} searched / ${manifest.skipped_session_count} skipped sessions, confidence ${manifest.confidence}`);
+    }
+  }
   lines.push("");
-  lines.push("## Mirror");
+  lines.push("## Operating Readout");
   lines.push("");
   lines.push(`### ${report.mirror.headline}`);
   lines.push("");
@@ -8272,13 +9448,13 @@ function renderWorkGraphMarkdown(report) {
     lines.push(`- ${claim.text} (${claim.evidence_refs.join(", ") || "no evidence refs"})`);
   }
   lines.push("");
-  lines.push("## Live Tension");
+  lines.push("## Operating Leakage");
   lines.push("");
   for (const metric of report.tension_metrics) {
     lines.push(`- ${metric.value} ${metric.label}: ${metric.explanation}`);
   }
   lines.push("");
-  lines.push("## Work Graph Trails");
+  lines.push("## Evidence Paths");
   lines.push("");
   for (const trail of report.trails.slice(0, 12)) {
     lines.push(`- [${trail.kind}] ${trail.title} \u2014 ${trail.state}, ${trail.valence}, ${trail.shape} (${trail.evidence_refs.join(", ")})`);
@@ -8316,12 +9492,36 @@ function renderWorkGraphMarkdown(report) {
     lines.push(`- [${kickoff.priority}] ${kickoff.title}: ${kickoff.summary}`);
   }
   lines.push("");
-  lines.push("## Eject Bay Recommendations");
+  lines.push("## Repair Recommendations");
   lines.push("");
   for (const recommendation of report.recommendations) {
     lines.push(`- [${recommendation.priority}] ${recommendation.title}: ${recommendation.summary}`);
   }
   lines.push("");
+  lines.push("## Attribution Spine");
+  lines.push("");
+  lines.push(`Source events: ${report.attribution_spine.source_events.length}`);
+  lines.push(`Evidence refs: ${report.attribution_spine.evidence_refs.length}`);
+  lines.push(`Review nodes: ${report.attribution_spine.review.pending_count}`);
+  lines.push(`Confidence: ${report.attribution_spine.confidence}`);
+  lines.push("");
+  const attributionGroups = [
+    ["Actions", report.attribution_spine.actions],
+    ["Decisions", report.attribution_spine.decisions],
+    ["Artifacts", report.attribution_spine.artifacts],
+    ["People", report.attribution_spine.people],
+    ["Businesses", report.attribution_spine.businesses],
+    ["Surfaces", report.attribution_spine.product_surfaces],
+    ["Sources", report.attribution_spine.sources]
+  ];
+  for (const [label, nodes] of attributionGroups) {
+    if (nodes.length === 0) continue;
+    lines.push(`${label}:`);
+    for (const node of nodes.slice(0, 5)) {
+      lines.push(`- ${node.label} (${node.evidence_refs.join(", ") || "source coverage"})`);
+    }
+    lines.push("");
+  }
   lines.push("## Signup Hydration");
   lines.push("");
   lines.push(`- Strategy: ${report.signup_hydration.strategy}`);
@@ -8337,8 +9537,314 @@ function renderWorkGraphMarkdown(report) {
   return lines.join("\n");
 }
 
+// src/lib/work-graph-publish.ts
+async function parseResponse(response) {
+  const text2 = await response.text();
+  if (!text2) return null;
+  try {
+    return JSON.parse(text2);
+  } catch {
+    return text2;
+  }
+}
+async function publishWorkGraphReport(report, options = {}) {
+  const auth = await resolveOrgxAuth();
+  if (!auth) {
+    throw new Error("OrgX auth is required to publish a Work Graph. Run `orgx-wizard auth login` or set ORGX_API_KEY.");
+  }
+  const url = buildOrgxApiUrl("/client/work-graph/reports", auth.baseUrl);
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${auth.apiKey}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      report,
+      ...options.workspaceId ? { workspace_id: options.workspaceId } : {},
+      ...options.initiativeId ? { initiative_id: options.initiativeId } : {},
+      ...options.entityType ? { entity_type: options.entityType } : {},
+      ...options.entityId ? { entity_id: options.entityId } : {},
+      ...options.artifactUrl ? { artifact_url: options.artifactUrl } : {},
+      attach_artifact: Boolean(options.attachArtifact),
+      public_share: Boolean(options.publicShare)
+    }),
+    signal: options.signal ?? AbortSignal.timeout(15e3)
+  });
+  return {
+    ok: response.ok,
+    status: response.status,
+    url,
+    data: await parseResponse(response)
+  };
+}
+async function publishWorkGraphEvents(fingerprint, patch, options = {}) {
+  const auth = await resolveOrgxAuth();
+  if (!auth) {
+    throw new Error("OrgX auth is required to replay Work Graph hook events. Run `orgx-wizard auth login` or set ORGX_API_KEY.");
+  }
+  const url = buildOrgxApiUrl("/client/work-graph/events", auth.baseUrl);
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${auth.apiKey}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      work_graph_fingerprint: fingerprint,
+      patch
+    }),
+    signal: options.signal ?? AbortSignal.timeout(15e3)
+  });
+  return {
+    ok: response.ok,
+    status: response.status,
+    url,
+    data: await parseResponse(response)
+  };
+}
+
+// src/lib/work-graph-hook-events.ts
+import { createHash as createHash5 } from "crypto";
+import { existsSync as existsSync6, readFileSync as readFileSync4 } from "fs";
+var SOURCE_CLIENTS = [
+  "codex",
+  "claude",
+  "claude-code",
+  "cursor",
+  "openclaw",
+  "slack",
+  "mcp",
+  "github",
+  "linear",
+  "gmail",
+  "calendar",
+  "notion",
+  "docs",
+  "manual",
+  "wizard",
+  "api",
+  "unknown"
+];
+function isRecord2(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function asString2(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function asNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function asStringArray(value) {
+  if (!Array.isArray(value)) return void 0;
+  return value.filter((item) => typeof item === "string" && item.trim().length > 0);
+}
+function stableHash(value) {
+  return createHash5("sha256").update(value).digest("hex").slice(0, 20);
+}
+function normalizeSourceClient2(value) {
+  const raw = asString2(value)?.toLowerCase();
+  if (!raw) return "unknown";
+  if (SOURCE_CLIENTS.includes(raw)) return raw;
+  if (raw === "claude_code") return "claude-code";
+  return "unknown";
+}
+function safeTimestamp(value) {
+  const raw = asString2(value);
+  if (raw && !Number.isNaN(Date.parse(raw))) return new Date(raw).toISOString();
+  return (/* @__PURE__ */ new Date(0)).toISOString();
+}
+function sourceLabel(sourceClient) {
+  switch (sourceClient) {
+    case "claude-code":
+      return "Claude Code";
+    case "codex":
+      return "Codex";
+    case "openclaw":
+      return "OpenClaw";
+    case "cursor":
+      return "Cursor";
+    default:
+      return sourceClient.replace(/[-_]/g, " ").replace(/\b\w/g, (char) => char.toUpperCase());
+  }
+}
+function readHookRecord(line) {
+  try {
+    const parsed = JSON.parse(line);
+    if (!isRecord2(parsed)) return null;
+    const record = {};
+    const schemaVersion = asString2(parsed.schema_version);
+    const source = asString2(parsed.source);
+    const sourceClient = asString2(parsed.source_client);
+    const event = asString2(parsed.event);
+    const sessionId = asString2(parsed.session_id);
+    const turnId = asString2(parsed.turn_id);
+    const cwd = asString2(parsed.cwd);
+    const transcriptPath = asString2(parsed.transcript_path);
+    const timestamp = asString2(parsed.timestamp);
+    if (schemaVersion) record.schema_version = schemaVersion;
+    if (source) record.source = source;
+    if (sourceClient) record.source_client = sourceClient;
+    if (event) record.event = event;
+    if (sessionId) record.session_id = sessionId;
+    if (turnId) record.turn_id = turnId;
+    if (cwd) record.cwd = cwd;
+    if (transcriptPath) record.transcript_path = transcriptPath;
+    if (timestamp) record.timestamp = timestamp;
+    if (isRecord2(parsed.summary)) {
+      const summary = {};
+      const toolName = asString2(parsed.summary.tool_name);
+      const promptChars = asNumber(parsed.summary.prompt_chars);
+      const payloadKeys = asStringArray(parsed.summary.payload_keys);
+      if (toolName) summary.tool_name = toolName;
+      if (promptChars !== void 0) summary.prompt_chars = promptChars;
+      if (payloadKeys) summary.payload_keys = payloadKeys;
+      record.summary = summary;
+    }
+    return record;
+  } catch {
+    return null;
+  }
+}
+function readRuntimeHookOutbox(path, limit = 200) {
+  if (!existsSync6(path)) return { path, records: [], skipped: 0 };
+  const lines = readFileSync4(path, "utf8").split(/\r?\n/).filter((line) => line.trim().length > 0);
+  const selected = lines.slice(Math.max(0, lines.length - Math.max(1, limit)));
+  const records = [];
+  let skipped = Math.max(0, lines.length - selected.length);
+  for (const line of selected) {
+    const record = readHookRecord(line);
+    if (record) {
+      records.push(record);
+    } else {
+      skipped += 1;
+    }
+  }
+  return { path, records, skipped };
+}
+function buildWorkGraphHookReplayPatch(readResult) {
+  const sourceEvents = [];
+  const evidenceRefs = [];
+  const sources = /* @__PURE__ */ new Map();
+  const agents = /* @__PURE__ */ new Map();
+  const tools = /* @__PURE__ */ new Map();
+  const dedupeKeys = /* @__PURE__ */ new Set();
+  readResult.records.forEach((record, index) => {
+    const sourceClient = normalizeSourceClient2(record.source_client);
+    const event = record.event ?? "runtime_hook";
+    const timestamp = safeTimestamp(record.timestamp);
+    const sourceId = record.session_id ?? record.transcript_path ?? record.cwd ?? `${sourceClient}:hook:${index}`;
+    const evidenceId = `hook:${stableHash(`${sourceClient}:${sourceId}:${event}:${timestamp}:${index}`)}`;
+    const toolName = record.summary?.tool_name;
+    const hasMcpTool = Boolean(toolName && /(mcp|orgx)/i.test(toolName));
+    const label = `${sourceLabel(sourceClient)} ${event}`;
+    const summary = hasMcpTool ? `${sourceLabel(sourceClient)} hook observed tool activity through ${toolName}.` : `${sourceLabel(sourceClient)} hook observed ${event} in the local runtime.`;
+    evidenceRefs.push({
+      id: evidenceId,
+      source_client: sourceClient,
+      source_id: sourceId,
+      label,
+      summary,
+      occurred_at: timestamp,
+      confidence: hasMcpTool ? 0.82 : 0.68,
+      redaction_state: "public_summary",
+      metadata: {
+        raw_transcript_sent: false,
+        hook_source: record.source ?? "runtime_hook",
+        cwd: record.cwd ?? null,
+        transcript_path: record.transcript_path ?? null
+      }
+    });
+    sourceEvents.push({
+      source_client: sourceClient,
+      source_id: sourceId,
+      source_label: sourceLabel(sourceClient),
+      event_type: hasMcpTool ? "mcp_call" : "runtime_hook",
+      occurred_at: timestamp,
+      evidence_ref: evidenceId,
+      confidence: hasMcpTool ? 0.82 : 0.68,
+      metadata: {
+        hook_event: event,
+        raw_transcript_sent: false,
+        prompt_chars: record.summary?.prompt_chars ?? null,
+        payload_keys: record.summary?.payload_keys ?? []
+      }
+    });
+    const sourceEvidence = sources.get(sourceClient) ?? [];
+    sourceEvidence.push(evidenceId);
+    sources.set(sourceClient, sourceEvidence.slice(0, 30));
+    dedupeKeys.add(`hook:${sourceClient}:${sourceId}:${event}`);
+    if (sourceClient !== "unknown") {
+      const agentId = `agent:${sourceClient}`;
+      agents.set(agentId, {
+        id: agentId,
+        kind: "agent",
+        label: sourceLabel(sourceClient),
+        summary: `${sourceLabel(sourceClient)} is emitting passive runtime hook evidence into this Work Graph.`,
+        source_client: sourceClient,
+        evidence_refs: sourceEvidence.slice(0, 30),
+        linked_node_ids: [`source:${sourceClient}`],
+        confidence: 0.7,
+        weight: 62,
+        review_state: "unreviewed",
+        dedupe_key: agentId,
+        metadata: { runtime_hook_replay: true }
+      });
+    }
+    if (toolName) {
+      const toolId = `tool:${stableHash(toolName.toLowerCase())}`;
+      const previous = tools.get(toolId);
+      const previousEvidence = Array.isArray(previous?.evidence_refs) ? previous.evidence_refs.filter((item) => typeof item === "string") : [];
+      tools.set(toolId, {
+        id: toolId,
+        kind: "tool",
+        label: toolName,
+        summary: hasMcpTool ? `Runtime hook evidence shows ${toolName} participating in OrgX/MCP work.` : `Runtime hook evidence shows ${toolName} participating in local work.`,
+        source_client: sourceClient,
+        evidence_refs: [...previousEvidence, evidenceId].slice(0, 30),
+        linked_node_ids: [`source:${sourceClient}`],
+        confidence: hasMcpTool ? 0.82 : 0.66,
+        weight: hasMcpTool ? 78 : 54,
+        review_state: "unreviewed",
+        dedupe_key: toolId,
+        metadata: { runtime_hook_replay: true }
+      });
+    }
+  });
+  const sourceNodes = [...sources.entries()].map(([sourceClient, refs]) => ({
+    id: `source:${sourceClient}`,
+    kind: "source",
+    label: sourceLabel(sourceClient),
+    summary: `${sourceLabel(sourceClient)} hook events have been replayed into this Work Graph profile.`,
+    source_client: sourceClient,
+    evidence_refs: refs.slice(0, 30),
+    linked_node_ids: [],
+    confidence: 0.7,
+    weight: 65,
+    review_state: "unreviewed",
+    dedupe_key: `source:${sourceClient}`,
+    metadata: { runtime_hook_replay: true }
+  }));
+  const patch = {
+    source_events: sourceEvents,
+    evidence_refs: evidenceRefs,
+    sources: sourceNodes,
+    agents: [...agents.values()],
+    tools: [...tools.values()],
+    dedupe_keys: [...dedupeKeys].slice(0, 200),
+    confidence: evidenceRefs.length > 0 ? 0.7 : 0
+  };
+  return {
+    patch,
+    records: readResult.records.length,
+    skipped: readResult.skipped,
+    sources: [...sources.keys()],
+    evidenceRefs: evidenceRefs.length
+  };
+}
+
 // src/lib/runtime-hooks.ts
-import { copyFileSync, existsSync as existsSync6, mkdirSync as mkdirSync3 } from "fs";
+import { copyFileSync, existsSync as existsSync7, mkdirSync as mkdirSync3 } from "fs";
 import { homedir as homedir2 } from "os";
 import { dirname as dirname4, join as join5 } from "path";
 var HOOK_MARKER = "orgx-session-hook.mjs";
@@ -8364,7 +9870,7 @@ function backupPath(path, now) {
   return `${path}.bak.${timestamp}`;
 }
 function backupExisting(path, now) {
-  if (!existsSync6(path)) return null;
+  if (!existsSync7(path)) return null;
   const backup = backupPath(path, now);
   copyFileSync(path, backup);
   return backup;
@@ -8562,7 +10068,7 @@ function inspectRuntimeHooks(options = {}) {
     installed: {
       claudeCode: hasOrgxHook(claudeSettingsRaw),
       codex: hasOrgxHook(codexHooksRaw),
-      hookScript: existsSync6(paths.hookScriptPath)
+      hookScript: existsSync7(paths.hookScriptPath)
     },
     codex: {
       configExists: Boolean(codexConfigRaw),
@@ -8762,12 +10268,72 @@ function printRuntimeHookInspection(report) {
   console.log(`  ${report.installed.claudeCode ? ICON.ok : ICON.warn}  ${pc3.bold("Claude Code ")} ${report.installed.claudeCode ? pc3.green("installed") : pc3.yellow("missing")}  ${pc3.dim(report.paths.claudeSettingsPath)}`);
   console.log(`  ${ICON.skip}  ${pc3.bold("outbox      ")} ${pc3.dim(`${report.outboxEvents} event${report.outboxEvents === 1 ? "" : "s"} at ${report.paths.outboxPath}`)}`);
 }
+function requireHookReplayApproval(options, interactive) {
+  if (options.yes) return true;
+  if (!interactive) {
+    throw new Error("Replaying Work Graph hook events requires --yes in non-interactive mode.");
+  }
+  return clack.confirm({
+    message: "Replay passive hook events into this claimed Work Graph profile?"
+  }).then((value) => {
+    if (clack.isCancel(value) || value !== true) {
+      clack.cancel("Hook replay cancelled.");
+      return false;
+    }
+    return true;
+  });
+}
+function parsePositiveInt(value, fallback) {
+  if (!value?.trim()) return fallback;
+  const parsed = Number.parseInt(value.trim(), 10);
+  if (!Number.isFinite(parsed) || parsed < 1) {
+    throw new Error(`Expected a positive integer, got ${value}`);
+  }
+  return parsed;
+}
+async function runHookReplayCommand(options) {
+  const fingerprint = options.fingerprint?.trim();
+  if (!fingerprint) {
+    throw new Error("Missing --fingerprint <wgf_...> for hook event replay.");
+  }
+  const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY);
+  const paths = inspectRuntimeHooks().paths;
+  const outboxPath = resolve(options.outbox?.trim() || paths.outboxPath);
+  const readResult = readRuntimeHookOutbox(outboxPath, parsePositiveInt(options.limit, 200));
+  const replay = buildWorkGraphHookReplayPatch(readResult);
+  if (replay.records === 0) {
+    if (options.json) {
+      console.log(JSON.stringify({ ok: true, published: false, reason: "empty_outbox", ...replay }, null, 2));
+      return;
+    }
+    console.log(`  ${ICON.skip}  ${pc3.bold("outbox      ")} ${pc3.dim(`no hook events found at ${outboxPath}`)}`);
+    return;
+  }
+  const approved = await requireHookReplayApproval(options, interactive);
+  if (!approved) return;
+  const result = await publishWorkGraphEvents(fingerprint, replay.patch);
+  if (!result.ok) process.exitCode = 1;
+  await safeTrackWizardTelemetry("hooks_replay_ran", {
+    command: "hooks replay",
+    fingerprint,
+    records: String(replay.records),
+    sources: replay.sources.join(","),
+    status: String(result.status)
+  });
+  if (options.json) {
+    console.log(JSON.stringify({ ...replay, published: result }, null, 2));
+    return;
+  }
+  console.log(`  ${result.ok ? ICON.ok : ICON.warn}  ${pc3.bold("replayed    ")} ${replay.records} hook event${replay.records === 1 ? "" : "s"}  ${pc3.dim(`status ${result.status}`)}`);
+  console.log(`  ${ICON.skip}  ${pc3.bold("sources     ")} ${pc3.dim(replay.sources.join(", ") || "none")}`);
+  console.log(`  ${ICON.skip}  ${pc3.bold("evidence    ")} ${pc3.dim(`${replay.evidenceRefs} public-summary ref${replay.evidenceRefs === 1 ? "" : "s"}`)}`);
+}
 function readAuditInput(options, interactive) {
   if (options.input?.trim()) {
-    return readFileSync5(resolve(options.input.trim()), "utf8");
+    return readFileSync6(resolve(options.input.trim()), "utf8");
   }
   if (!process.stdin.isTTY) {
-    return readFileSync5(0, "utf8");
+    return readFileSync6(0, "utf8");
   }
   if (!interactive) {
     throw new Error("Audit input is required. Pass --input <file> or pipe text into wizard audit.");
@@ -8800,7 +10366,7 @@ function collectPathOption(value, previous = []) {
 }
 function parseClientExtractionFile(path) {
   const resolvedPath = resolve(path);
-  const parsed = JSON.parse(readFileSync5(resolvedPath, "utf8"));
+  const parsed = JSON.parse(readFileSync6(resolvedPath, "utf8"));
   if (!isRecord(parsed)) {
     throw new Error(`AI-client extraction must be a JSON object: ${resolvedPath}`);
   }
@@ -8839,6 +10405,11 @@ async function readAuditImports(options, interactive) {
       imports.push({
         sourceId: "wizard-audit-input",
         sourceLabel: options.sourceLabel?.trim() || "Wizard audit input",
+        metadata: {
+          message_count: 1,
+          retained_line_count: text2.split(/\r?\n/).filter(Boolean).length,
+          source_client: "manual"
+        },
         text: text2
       });
       connectedSources.push(options.sourceLabel?.trim() || "Manual AI-session import");
@@ -8902,6 +10473,22 @@ function requireWriteApproval(options, interactive) {
     return true;
   });
 }
+function requireWorkGraphPublishApproval(options, interactive) {
+  const wantsPublish = Boolean(options.publish || options.publicShare);
+  if (!wantsPublish || options.yes || options.dryRun) return true;
+  if (!interactive) {
+    throw new Error("Publishing a Work Graph requires --yes in non-interactive mode.");
+  }
+  return clack.confirm({
+    message: "Publish this Work Graph to OrgX and create a shareable profile?"
+  }).then((value) => {
+    if (clack.isCancel(value) || value !== true) {
+      clack.cancel("Work Graph publish cancelled.");
+      return false;
+    }
+    return true;
+  });
+}
 async function resolveAuditWorkspace(options) {
   const explicitId = options.workspaceId?.trim();
   const explicitName = options.workspaceName?.trim();
@@ -9021,18 +10608,27 @@ async function runWorkGraphCommand(options, defaults = {}) {
   };
   const auditInputs = await readWorkGraphInputs(commandOptions, interactive);
   const workspace = await resolveAuditWorkspace(commandOptions);
+  const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const nativeClientExtractions = buildNativeAiClientExtractions(
+    auditInputs.imports,
+    generatedAt
+  );
+  const clientExtractions = [
+    ...auditInputs.clientExtractions,
+    ...nativeClientExtractions
+  ];
   const report = buildSessionReconciliationReport({
-    clientExtractions: auditInputs.clientExtractions,
+    clientExtractions,
     connectedSources: [
       ...auditInputs.connectedSources,
       ...workspace.id === "local-workspace" ? [] : ["OrgX workspace"]
     ],
-    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     imports: auditInputs.imports,
     missingSources: [
       ...workspace.id === "local-workspace" ? ["OrgX workspace auth"] : [],
       ...auditInputs.missingSources
     ],
+    generatedAt,
     workspace
   });
   const markdown = renderWorkGraphMarkdown(report);
@@ -9042,6 +10638,39 @@ async function runWorkGraphCommand(options, defaults = {}) {
   const markdownPath = resolve(outputDir, `work-graph-report-${timestamp}.md`);
   writeJsonFile(jsonPath, report);
   writeTextFile(markdownPath, markdown);
+  let published = null;
+  const shouldPublish = Boolean(commandOptions.publish || commandOptions.publicShare);
+  if (shouldPublish) {
+    const approved = await requireWorkGraphPublishApproval(commandOptions, interactive);
+    if (approved) {
+      if (commandOptions.dryRun) {
+        published = { ok: true, status: 0 };
+      } else {
+        const publishResult = await publishWorkGraphReport(report, {
+          ...commandOptions.artifactUrl?.trim() ? { artifactUrl: commandOptions.artifactUrl.trim() } : {},
+          attachArtifact: Boolean(commandOptions.attachArtifact || commandOptions.attachToInitiative),
+          ...commandOptions.entityId?.trim() ? { entityId: commandOptions.entityId.trim() } : {},
+          ...commandOptions.entityType ? { entityType: commandOptions.entityType } : {},
+          ...commandOptions.attachToInitiative?.trim() ? { initiativeId: commandOptions.attachToInitiative.trim() } : {},
+          publicShare: Boolean(commandOptions.publicShare || commandOptions.publish),
+          ...workspace.id !== "local-workspace" ? { workspaceId: workspace.id } : {}
+        });
+        if (!publishResult.ok) {
+          throw new Error(`Work Graph publish failed with HTTP ${publishResult.status}: ${JSON.stringify(publishResult.data)}`);
+        }
+        const body = isRecord(publishResult.data) ? publishResult.data : {};
+        const publicShare = isRecord(body.public_share) ? body.public_share : null;
+        const publicUrl = typeof publicShare?.url === "string" ? `${normalizeOrgxBaseUrl(process.env.ORGX_BASE_URL || DEFAULT_ORGX_BASE_URL)}${publicShare.url}` : void 0;
+        const readout = isRecord(body.public_readout) ? body.public_readout : null;
+        published = {
+          ok: true,
+          status: publishResult.status,
+          ...publicUrl ? { publicUrl } : {},
+          ...typeof readout?.review_url === "string" ? { reviewUrl: readout.review_url } : {}
+        };
+      }
+    }
+  }
   if (commandOptions.json) {
     console.log(JSON.stringify({
       jsonPath,
@@ -9051,13 +10680,17 @@ async function runWorkGraphCommand(options, defaults = {}) {
       hydrationKey: report.signup_hydration.hydration_key,
       finalState: report.final_state,
       opportunityScore: report.opportunity_score,
+      executionQuality: report.execution_quality,
+      impactProjection: report.impact_projection,
       missedOrchestration: report.missed_orchestration_opportunities.length,
       clientExtractionCount: report.client_extractions.length,
       kickoffCount: report.initiative_kickoffs.length,
-      trailCount: report.trails.length,
+      findingCount: report.trails.length,
       recurringPatternCount: report.recurring_patterns.length,
-      topTrail: report.mirror.primary_trail_id ?? null,
-      mirrorHeadline: report.mirror.headline
+      attributionCount: report.attribution_spine.review.pending_count,
+      topFinding: report.mirror.primary_trail_id ?? null,
+      readoutHeadline: report.mirror.headline,
+      published
     }, null, 2));
     return;
   }
@@ -9067,11 +10700,13 @@ async function runWorkGraphCommand(options, defaults = {}) {
   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))}`);
+  console.log(`  ${ICON.ok}  ${pc3.green("quality       ")} ${pc3.dim(`${report.execution_quality.overall}/100 \xB7 coverage ${report.source_coverage.coverage_score ?? 0}/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`)}`);
   const missed = report.missed_orchestration_opportunities.length;
   const missedColor = missed > 0 ? pc3.yellow : pc3.green;
   console.log(`  ${missed > 0 ? ICON.warn : ICON.ok}  ${missedColor("missed        ")} ${pc3.dim(`${missed} orchestration opportunit${missed === 1 ? "y" : "ies"}`)}`);
-  console.log(`  ${ICON.ok}  ${pc3.green("trails        ")} ${pc3.dim(`${report.trails.length} trail${report.trails.length === 1 ? "" : "s"} \xB7 ${report.recurring_patterns.length} recurring pattern${report.recurring_patterns.length === 1 ? "" : "s"}`)}`);
-  console.log(`  ${ICON.skip}  ${pc3.bold("mirror       ")} ${report.mirror.headline}`);
+  console.log(`  ${ICON.ok}  ${pc3.green("findings      ")} ${pc3.dim(`${report.trails.length} finding${report.trails.length === 1 ? "" : "s"} \xB7 ${report.recurring_patterns.length} recurring pattern${report.recurring_patterns.length === 1 ? "" : "s"}`)}`);
+  console.log(`  ${ICON.skip}  ${pc3.bold("readout      ")} ${report.mirror.headline}`);
   for (const metric of report.tension_metrics.slice(0, 4)) {
     const tone = metric.tone === "danger" ? pc3.red : metric.tone === "warning" ? pc3.yellow : metric.tone === "good" ? pc3.green : pc3.dim;
     console.log(`  ${ICON.skip}  ${tone(`${metric.value} ${metric.label}`)} ${pc3.dim(metric.explanation)}`);
@@ -9079,6 +10714,10 @@ async function runWorkGraphCommand(options, defaults = {}) {
   for (const kickoff of report.initiative_kickoffs) {
     console.log(`  ${ICON.skip}  ${pc3.bold(kickoff.priority.padEnd(3))} ${kickoff.title}`);
   }
+  console.log(`  ${ICON.ok}  ${pc3.green("attribution ")} ${pc3.dim(`${report.attribution_spine.review.pending_count} nodes \xB7 ${report.attribution_spine.source_events.length} source events`)}`);
+  if (published?.publicUrl) {
+    console.log(`  ${ICON.ok}  ${pc3.green("profile      ")} ${pc3.bold(published.publicUrl)}`);
+  }
 }
 async function checkPluginStatusesCompact() {
   const spinner = createOrgxSpinner("Checking OrgX companion plugin status");
@@ -10038,7 +11677,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.32" : void 0;
+  const pkgVersion = true ? "0.1.37" : void 0;
   program.version(pkgVersion ?? "unknown", "-V, --version");
   program.hook("preAction", (_thisCommand, actionCommand) => {
     if (Boolean(actionCommand.optsWithGlobals().json)) return;
@@ -10738,22 +12377,22 @@ 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("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) => {
+  const workGraph = program.command("work-graph").description("Build a redacted OrgX Profile from AI-client session search, Slack, MCP, or manual context.");
+  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",
       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) => {
+  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: codex, claude, 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 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) => {
+  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: codex, claude, 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"
@@ -10761,7 +12400,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("--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) => {
+  sessions.command("reconcile").description("Backfill recent Codex and Claude sessions into a redacted OrgX Profile 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", "25").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("--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("--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("sessions_reconcile_started", {
       command: "sessions reconcile",
       from: options.from ?? "all"
@@ -10805,6 +12444,9 @@ async function main() {
       }
     }
   });
+  hooks.command("replay").description("Replay passive hook outbox events into a claimed Work Graph profile.").requiredOption("--fingerprint <fingerprint>", "target Work Graph fingerprint, for example wgf_0123...").option("--outbox <path>", "runtime hook JSONL outbox path").option("--limit <count>", "maximum recent hook events to replay", "200").option("--yes", "approve publishing hook evidence without prompting").option("--json", "emit a JSON command summary").action(async (options) => {
+    await runHookReplayCommand(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();