@useorgx/wizard 0.1.32 → 0.1.36

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";
@@ -6990,6 +6990,7 @@ var WORK_GRAPH_FINDING_TYPES = [
   "business",
   "product_surface",
   "goal",
+  "outcome",
   "initiative_candidate",
   "missed_orchestration_opportunity"
 ];
@@ -7022,6 +7023,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 +7035,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 +7044,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 +7094,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}`;
@@ -7093,9 +7149,15 @@ function buildWorkGraphExtractionProtocol() {
       {
         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.",
+        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 trails",
+        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",
@@ -7124,7 +7186,7 @@ function buildWorkGraphExtractionProtocol() {
     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: [
@@ -7143,9 +7205,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",
@@ -7219,6 +7282,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,14 +7304,150 @@ ${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 inferredConnected = [
+    ...connectedSources,
+    ...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 key = `${manifest.source_client}:${manifest.source_label}`;
+    const previous = manifests.get(key);
+    if (!previous) {
+      manifests.set(key, manifest);
+      return;
+    }
+    manifests.set(key, {
+      ...previous,
+      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 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 "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) => {
@@ -7252,9 +7457,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,6 +7483,8 @@ 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
     }
   }));
@@ -7283,13 +7493,14 @@ 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 +7510,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 +7524,124 @@ 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: [
+      {
+        id: "native_session_episodes",
+        lens: `${labelForSourceClient(sourceClient)} episode extraction`,
+        query: "Extract decisions, artifacts, blockers, outcomes, handoffs, and missed OrgX writeback from local AI-client session lines.",
+        result_count: bucket.findings.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;
@@ -7466,9 +7795,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 trails into automated attribution, decisions, and source connections.",
+      "Impact is directional until the user claims the fingerprint and confirms or corrects trail 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 trails, source-specific evidence, and action recommendations tied to impact.",
+      multiEventTrails === trails.length ? "Every trail has multiple evidence events." : `${trails.length - multiEventTrails} trail${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 +7938,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 +7992,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 +8004,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 +8012,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 +8020,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 trail`;
+    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 trail 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 +8123,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)
     };
   });
 }
@@ -7796,9 +8265,12 @@ 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",
+      title: topBlockerTrail && topBlockerTrail.events.length > 1 ? `${topBlockerTrail.title} and needs owner-visible resolution` : "Blockers are becoming handoff friction",
       description: `${blockerTrails.length} blocker trail${blockerTrails.length === 1 ? "" : "s"} need owner-visible resolution.`,
       pattern_type: "handoff_friction",
       affected_trail_ids: blockerTrails.map((trail) => trail.id),
@@ -7872,6 +8344,18 @@ 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 trail",
+        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",
@@ -7900,17 +8384,24 @@ 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 { coverage, generatedAt, impact, patterns, recommendations, trails } = input;
   const topTrail = [...trails].sort((a, b) => b.impact_score - a.impact_score)[0];
   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 trail is breaking" : sourceGapCount > 0 ? "Your work leaves trails, but the proof chain is still incomplete" : topPattern ? "Your work has a recurring operating pattern worth preserving" : topTrail ? "Your work is becoming an operating profile" : "Your work is leaving an operating trail";
   const primaryClaimRefs = topTrail?.evidence_refs ?? [];
   const claims = [
     {
@@ -7927,17 +8418,25 @@ function buildWorkGraphMirror(input) {
     },
     {
       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 trails become durable.`,
+      evidence_refs: trails.flatMap((trail) => trail.evidence_refs).slice(0, 6),
+      confidence: impact.confidence
+    }] : []
   ];
   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(" ");
+    `You have real work moving across ${sourcePhrase}: OrgX found ${trails.length} evidence trail${trails.length === 1 ? "" : "s"} without requiring OrgX tool calls to be present.`,
+    topPattern ? `The strongest recurring pattern is ${topPattern.title.toLowerCase()}, with ${topPattern.recurrence_count} appearance${topPattern.recurrence_count === 1 ? "" : "s"} still needing durable writeback.` : topTrail ? `The clearest trail is ${topTrail.title.toLowerCase()}, but it still needs stronger chronology before it becomes durable operating memory.` : "The first profile is forming from sparse evidence and should be reviewed before promotion.",
+    blockerCount > 0 ? `${blockerCount} blocker trail${blockerCount === 1 ? "" : "s"} keep work returning as new work instead of becoming owner-visible resolution.` : `${decisionCount} decision trail${decisionCount === 1 ? "" : "s"} and ${artifactCount} artifact trail${artifactCount === 1 ? "" : "s"} already show where work can be preserved.`,
+    sourceGapCount > 0 ? `${sourceGapCount} source gap${sourceGapCount === 1 ? "" : "s"} still limit trust, especially ownership, handoffs, and 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, +${impact.acceleration_percent}% acceleration, 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 trail before publishing it."
+  ].filter(Boolean).join(" ");
   return {
     headline,
     body,
@@ -7948,13 +8447,39 @@ function buildWorkGraphMirror(input) {
   };
 }
 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, trail 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",
@@ -8011,6 +8536,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(
@@ -8108,18 +8944,41 @@ function buildSessionReconciliationReport(input) {
   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({
     coverage,
     generatedAt,
+    impact: impactProjection,
     patterns: recurringPatterns,
     recommendations,
     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,
@@ -8167,7 +9026,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
@@ -8254,13 +9116,44 @@ 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(`Trail 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("");
@@ -8322,6 +9215,30 @@ function renderWorkGraphMarkdown(report) {
     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 +9254,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 +9587,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 +9785,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 +9985,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 +10083,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}`);
   }
@@ -8902,6 +10185,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 +10320,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 +10350,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 +10392,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,
       recurringPatternCount: report.recurring_patterns.length,
+      attributionCount: report.attribution_spine.review.pending_count,
       topTrail: report.mirror.primary_trail_id ?? null,
-      mirrorHeadline: report.mirror.headline
+      mirrorHeadline: report.mirror.headline,
+      published
     }, null, 2));
     return;
   }
@@ -9067,6 +10412,8 @@ 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"}`)}`);
@@ -9079,6 +10426,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 +11389,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.36" : void 0;
   program.version(pkgVersion ?? "unknown", "-V, --version");
   program.hook("preAction", (_thisCommand, actionCommand) => {
     if (Boolean(actionCommand.optsWithGlobals().json)) return;
@@ -10753,7 +12104,7 @@ async function main() {
     });
     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 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("--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 +12112,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 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("--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 +12156,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();