@useorgx/wizard 0.1.26 → 0.1.28

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 readFileSync4 } from "fs";
+import { readFileSync as readFileSync5 } from "fs";
 import { hostname } from "os";
 import { resolve } from "path";
 import { Command } from "commander";
@@ -6228,7 +6228,7 @@ var AI_SESSION_SOURCES = ["codex", "claude"];
 var DEFAULT_LIMIT_PER_SOURCE = 3;
 var DEFAULT_SINCE_DAYS = 30;
 var DEFAULT_MAX_BYTES_PER_FILE = 1e6;
-var AUDIT_RELEVANT_LINE_PATTERN = /\b(decision|decided|artifact|receipt|proof|commitment|committed|next action|follow[- ]?up|outcome|result|impact|roi|economics|token|cost|saved|open loop|gap|blocker|risk|owner|dri|writeback|rollback|quality score)\b/i;
+var AUDIT_RELEVANT_LINE_PATTERN = /\b(decision|decided|artifact|receipt|proof|commitment|committed|next action|follow[- ]?up|outcome|result|impact|roi|economics|token|cost|saved|open loop|gap|blocker|risk|owner|dri|writeback|rollback|quality score|mcp|tool call|orgx_emit_activity|orgx_apply_changeset|complete_with_proof|scaffold_initiative|mcp__orgx__)\b/i;
 function parseAiSessionSources(value) {
   if (!value?.trim()) return [];
   const requested = value.split(",").map((item) => item.trim().toLowerCase()).filter(Boolean);
@@ -6889,6 +6889,1338 @@ Rollback: ${plan.recommended_follow_up.rollback}`,
   );
 }
 
+// src/lib/work-graph.ts
+import { createHash as createHash4 } from "crypto";
+var WORK_GRAPH_SCHEMA_VERSION = "2026-05-07";
+var WORK_GRAPH_FINGERPRINT_VERSION = "wgf_v1";
+function clampScore2(value) {
+  return Math.max(0, Math.min(100, Math.round(value)));
+}
+function hashJson(value) {
+  return createHash4("sha256").update(JSON.stringify(value)).digest("hex");
+}
+function normalizeFingerprintText(value) {
+  return value.toLowerCase().replace(/https?:\/\/\S+/g, "url").replace(/[0-9a-f]{12,}/g, "hash").replace(/\b[0-9a-f]{8}-[0-9a-f-]{27,}\b/g, "uuid").replace(/\s+/g, " ").trim().slice(0, 600);
+}
+function shortHash(value, length = 16) {
+  return hashJson(value).slice(0, length);
+}
+function sortedUnique(values) {
+  return [...new Set(values)].sort();
+}
+function slugPart(value) {
+  const normalized = normalizeFingerprintText(value).replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 64);
+  return normalized || "unknown";
+}
+function sourceClientForImport(source) {
+  const raw = `${source.sourceId} ${source.sourceLabel}`.toLowerCase();
+  if (raw.includes("codex")) return "codex";
+  if (raw.includes("claude-code")) return "claude-code";
+  if (raw.includes("claude")) return "claude";
+  if (raw.includes("cursor")) return "cursor";
+  if (raw.includes("openclaw")) return "openclaw";
+  if (raw.includes("slack")) return "slack";
+  if (raw.includes("github")) return "github";
+  if (raw.includes("linear")) return "linear";
+  if (raw.includes("mcp")) return "mcp";
+  if (raw.includes("api")) return "api";
+  if (raw.includes("manual") || raw.includes("wizard-audit-input")) return "manual";
+  return "unknown";
+}
+function titleFromText(text2, fallback) {
+  const normalized = text2.replace(/^\s*(decision|artifact|commitment|next action|follow[- ]?up|outcome|roi|economics|open loop|gap|blocker|risk|goal)\s*:\s*/i, "").trim();
+  const firstSentence = normalized.split(/[.!?]\s/)[0]?.trim() || normalized;
+  return (firstSentence || fallback).slice(0, 160);
+}
+function findingTypeForItem(item) {
+  switch (item.type) {
+    case "decision":
+      return "decision";
+    case "artifact":
+      return "artifact";
+    case "open_loop":
+      return "blocker";
+    case "commitment":
+    case "next_action":
+    case "outcome":
+      return "action";
+    case "economics":
+      return "business";
+  }
+}
+function evidenceRefFor(sourceId, index) {
+  return `${sourceId}:derived:${index + 1}`;
+}
+function includesAny2(text2, patterns) {
+  return patterns.some((pattern) => pattern.test(text2));
+}
+function buildCoverage(imports, connectedSources, missingSources) {
+  const allText = imports.map((source) => source.text).join("\n").toLowerCase();
+  const orgxObserved = /\borgx\b|useorgx|mcp__orgx__|orgx_/i.test(allText);
+  const mcpObserved = /\bmcp\b|mcp__|tool call|tools\/call|call_tool|orgx_emit_activity/i.test(allText);
+  const orgxMcpCalled = /mcp__orgx__|orgx_emit_activity|orgx_apply_changeset|complete_with_proof|scaffold_initiative/i.test(allText);
+  const skillOnlySignal = orgxObserved && !orgxMcpCalled && /\bskill|instructions|agent|workflow\b/i.test(allText);
+  return {
+    connected: [...connectedSources],
+    missing: [...missingSources],
+    mcpObserved,
+    orgxObserved,
+    orgxMcpCalled,
+    skillOnlySignal
+  };
+}
+function buildDerivedFindings(imports) {
+  const findings = [];
+  let derivedIndex = 0;
+  for (const source of imports) {
+    const sourceClient = sourceClientForImport(source);
+    const lines = source.text.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+    for (const line of lines) {
+      const lower = line.toLowerCase();
+      if (includesAny2(lower, [/\b(owner|dri|founder|teammate|customer|user|stakeholder|buyer|reviewer)\b/])) {
+        findings.push({
+          type: "person",
+          title: titleFromText(line, "Person or stakeholder signal"),
+          summary: line,
+          source_client: sourceClient,
+          source_id: source.sourceId,
+          evidence_ref: evidenceRefFor(source.sourceId, derivedIndex++),
+          confidence: 0.62,
+          metadata: { source_label: source.sourceLabel }
+        });
+      }
+      if (includesAny2(lower, [/\b(product surface|surface|live room|command center|dashboard|widget|plugin|wizard|audit|onboarding|mcp|slack|github|linear)\b/])) {
+        findings.push({
+          type: "product_surface",
+          title: titleFromText(line, "Product surface signal"),
+          summary: line,
+          source_client: sourceClient,
+          source_id: source.sourceId,
+          evidence_ref: evidenceRefFor(source.sourceId, derivedIndex++),
+          confidence: 0.66,
+          metadata: { source_label: source.sourceLabel }
+        });
+      }
+      if (includesAny2(lower, [/\b(goal|objective|initiative|workstream|milestone|roadmap|launch)\b/])) {
+        findings.push({
+          type: "goal",
+          title: titleFromText(line, "Goal signal"),
+          summary: line,
+          source_client: sourceClient,
+          source_id: source.sourceId,
+          evidence_ref: evidenceRefFor(source.sourceId, derivedIndex++),
+          confidence: 0.64,
+          metadata: { source_label: source.sourceLabel }
+        });
+      }
+    }
+  }
+  return findings;
+}
+function buildWorkGraphEvents(imports) {
+  return imports.map((source, index) => ({
+    schema_version: WORK_GRAPH_SCHEMA_VERSION,
+    source_client: sourceClientForImport(source),
+    source_id: source.sourceId,
+    source_label: source.sourceLabel,
+    event_type: "session_excerpt",
+    text: source.text,
+    evidence_ref: `${source.sourceId}:excerpt`,
+    metadata: {
+      import_index: index,
+      line_count: source.text.split(/\r?\n/).filter(Boolean).length,
+      raw_transcript_sent: false
+    }
+  }));
+}
+function buildWorkGraphFindings(imports) {
+  const loopFindings = extractFounderLoopItems(imports).map((item) => {
+    const source = imports.find((candidate) => candidate.sourceId === item.sourceId);
+    const sourceClient = source ? sourceClientForImport(source) : "unknown";
+    const type = findingTypeForItem(item);
+    return {
+      type,
+      title: titleFromText(item.text, type),
+      summary: item.text,
+      source_client: sourceClient,
+      source_id: item.sourceId,
+      evidence_ref: item.evidenceRef,
+      confidence: type === "decision" || type === "artifact" ? 0.82 : 0.72,
+      metadata: {
+        source_label: item.sourceLabel,
+        founder_loop_type: item.type,
+        line_number: item.lineNumber
+      }
+    };
+  });
+  const seen = /* @__PURE__ */ new Set();
+  return [...loopFindings, ...buildDerivedFindings(imports)].filter((finding) => {
+    const key = `${finding.type}:${finding.source_id}:${finding.summary.toLowerCase()}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+function buildMissedOpportunities(coverage, findings) {
+  const opportunities = [];
+  const hasActionableSignal = findings.some(
+    (finding) => ["decision", "artifact", "blocker", "action"].includes(finding.type)
+  );
+  if (hasActionableSignal && !coverage.orgxMcpCalled) {
+    opportunities.push({
+      type: "missed_orchestration_opportunity",
+      title: "High-value work happened without an OrgX MCP write",
+      summary: "The source contains decisions, artifacts, blockers, or actions, but no durable OrgX MCP call was detected.",
+      source_client: "wizard",
+      source_id: "work-graph",
+      evidence_ref: "work-graph:coverage:orgx-mcp",
+      confidence: coverage.orgxObserved ? 0.78 : 0.7,
+      metadata: {
+        orgx_observed: coverage.orgxObserved,
+        mcp_observed: coverage.mcpObserved,
+        skill_only_signal: coverage.skillOnlySignal
+      }
+    });
+  }
+  if (coverage.missing.length > 0) {
+    opportunities.push({
+      type: "missed_orchestration_opportunity",
+      title: "Source coverage is incomplete",
+      summary: `Missing sources: ${coverage.missing.join(", ")}.`,
+      source_client: "wizard",
+      source_id: "work-graph",
+      evidence_ref: "work-graph:coverage:missing",
+      confidence: 0.76,
+      metadata: { missing_sources: coverage.missing }
+    });
+  }
+  return opportunities;
+}
+function scoreOpportunity(coverage, findings) {
+  const count = (type) => findings.filter((finding) => finding.type === type).length;
+  const decisions = count("decision");
+  const artifacts = count("artifact");
+  const blockers = count("blocker");
+  const actions = count("action");
+  const people = count("person");
+  const business = count("business");
+  const surfaces = count("product_surface");
+  const goals = count("goal");
+  const evidenceQuality = clampScore2(35 + Math.min(35, artifacts * 9 + decisions * 6) + Math.min(20, coverage.connected.length * 6) - coverage.missing.length * 8);
+  const urgency = clampScore2(20 + blockers * 18 + actions * 7 + decisions * 5);
+  const ownerClarity = clampScore2(25 + people * 18 + (findings.some((finding) => /\b(owner|dri|responsible|founder)\b/i.test(finding.summary)) ? 35 : 0));
+  const automationPotential = clampScore2(30 + actions * 10 + surfaces * 7 + (coverage.mcpObserved ? 12 : 0));
+  const valuePotential = clampScore2(25 + business * 20 + artifacts * 8 + goals * 10 + surfaces * 5);
+  const orgxFit = clampScore2(35 + decisions * 8 + blockers * 10 + artifacts * 7 + (coverage.orgxObserved ? 10 : 0) + (!coverage.orgxMcpCalled ? 10 : 0));
+  return {
+    overall: clampScore2((valuePotential + evidenceQuality + urgency + ownerClarity + automationPotential + orgxFit) / 6),
+    value_potential: valuePotential,
+    evidence_quality: evidenceQuality,
+    urgency,
+    owner_clarity: ownerClarity,
+    automation_potential: automationPotential,
+    orgx_fit: orgxFit
+  };
+}
+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))) {
+    return "completed";
+  }
+  if (findings.some((finding) => finding.type === "action" || finding.type === "decision")) return "in_progress";
+  return "unknown";
+}
+function buildKickoffs(findings, missed, score) {
+  const blockers = findings.filter((finding) => finding.type === "blocker").slice(0, 3);
+  const decisions = findings.filter((finding) => finding.type === "decision").slice(0, 3);
+  const artifacts = findings.filter((finding) => finding.type === "artifact").slice(0, 3);
+  const kickoffs = [];
+  if (missed.length > 0) {
+    kickoffs.push({
+      title: "Install continuous OrgX writeback",
+      summary: "Turn detected work into live OrgX activity, retro, outcome, and decision records.",
+      reason: missed[0]?.summary ?? "A source produced work without durable OrgX orchestration.",
+      finding_refs: missed.map((finding) => finding.evidence_ref).slice(0, 4),
+      priority: score.overall >= 75 ? "p0" : "p1"
+    });
+  }
+  if (blockers.length > 0 || decisions.length > 0) {
+    kickoffs.push({
+      title: "Resolve the hidden decision queue",
+      summary: "Convert unresolved decisions and blockers into owner-visible OrgX decision cards.",
+      reason: "The Work Graph found decisions or blockers that can slow execution if they stay buried in transcripts.",
+      finding_refs: [...blockers, ...decisions].map((finding) => finding.evidence_ref).slice(0, 5),
+      priority: blockers.length > 0 ? "p0" : "p1"
+    });
+  }
+  if (artifacts.length > 0) {
+    kickoffs.push({
+      title: "Attach proof to the operating loop",
+      summary: "Promote completed work into artifacts with owners, evidence refs, and next actions.",
+      reason: "Completed work was detected; OrgX can make it queryable and reusable.",
+      finding_refs: artifacts.map((finding) => finding.evidence_ref),
+      priority: "p1"
+    });
+  }
+  if (kickoffs.length === 0) {
+    kickoffs.push({
+      title: "Connect first work source",
+      summary: "Add AI client, Slack, or MCP source coverage so OrgX can build a useful Work Graph.",
+      reason: "The scan did not find enough structured work to recommend a specific operating initiative.",
+      finding_refs: [],
+      priority: "p2"
+    });
+  }
+  return kickoffs.slice(0, 3);
+}
+function entityTypeForFinding(finding) {
+  switch (finding.type) {
+    case "decision":
+      return "decision";
+    case "artifact":
+      return "artifact";
+    case "blocker":
+      return "blocker";
+    case "person":
+      return "person";
+    case "business":
+      return "business";
+    case "product_surface":
+      return "surface";
+    case "goal":
+    case "initiative_candidate":
+      return "initiative";
+    case "action":
+      return /\b(outcome|shipped|completed|verified)\b/i.test(finding.summary) ? "outcome" : "task";
+    case "missed_orchestration_opportunity":
+      return "source";
+  }
+}
+function trailKindForEntity(entityType) {
+  switch (entityType) {
+    case "decision":
+      return "decision_trail";
+    case "artifact":
+      return "artifact_trail";
+    case "person":
+      return "person_trail";
+    case "business":
+      return "business_trail";
+    case "blocker":
+      return "blocker_trail";
+    case "agent":
+      return "agent_trail";
+    case "tool":
+    case "source":
+      return "source_trail";
+    case "outcome":
+      return "outcome_trail";
+    case "idea":
+      return "idea_trail";
+    case "initiative":
+    case "workstream":
+    case "milestone":
+    case "task":
+    case "surface":
+      return "initiative_trail";
+  }
+}
+function eventTypeForFinding(finding) {
+  switch (finding.type) {
+    case "decision":
+      return "decision_inferred";
+    case "artifact":
+      return /\b(verified|proof|tested|passed)\b/i.test(finding.summary) ? "artifact_verified" : "artifact_created";
+    case "blocker":
+      return "blocker_detected";
+    case "person":
+      return "owner_assigned";
+    case "business":
+      return "signal_detected";
+    case "product_surface":
+      return "signal_detected";
+    case "goal":
+    case "initiative_candidate":
+      return "initiative_created";
+    case "action":
+      return /\b(outcome|result|impact|roi)\b/i.test(finding.summary) ? "outcome_recorded" : "recommendation_generated";
+    case "missed_orchestration_opportunity":
+      return "source_connected";
+  }
+}
+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 === "decision")) return "inferred";
+  return "observed";
+}
+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 === "business")) return "opportunity";
+  if (findings.some((finding) => finding.type === "artifact")) return "healthy";
+  return recurrence > 1 ? "useful_recurrence" : "opportunity";
+}
+function trailShapeForFindings(findings, recurrence) {
+  const decisions = findings.filter((finding) => finding.type === "decision").length;
+  const artifacts = findings.filter((finding) => finding.type === "artifact").length;
+  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 (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";
+  return "dense_recent_cluster";
+}
+function buildWorkGraphTrails(findings, generatedAt) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const finding of findings) {
+    const entityType = entityTypeForFinding(finding);
+    const key = `${entityType}:${slugPart(finding.title)}`;
+    grouped.set(key, [...grouped.get(key) ?? [], finding]);
+  }
+  return [...grouped.entries()].map(([key, group], index) => {
+    const first = group[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) => ({
+      id: `${trailId}:event:${eventIndex + 1}`,
+      trail_id: trailId,
+      event_type: eventTypeForFinding(finding),
+      entity_id: entityId,
+      entity_type: entityType,
+      timestamp: generatedAt,
+      source_id: finding.source_id,
+      source_type: finding.source_client,
+      redacted_verbatim: finding.summary.slice(0, 320),
+      confidence: finding.confidence,
+      evidence_refs: [finding.evidence_ref],
+      privacy_state: "redacted"
+    }));
+    const edges = events.slice(1).map((event, edgeIndex) => ({
+      id: `${trailId}:edge:${edgeIndex + 1}`,
+      from_event_id: events[edgeIndex].id,
+      to_event_id: event.id,
+      relation: group.some((finding) => finding.type === "blocker") ? "blocked" : "informed",
+      state: recurrence > 1 ? "captured" : "inferred",
+      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;
+    return {
+      id: trailId,
+      kind: trailKindForEntity(entityType),
+      title: first.title,
+      summary: first.summary,
+      subject_entity_id: entityId,
+      subject_entity_type: entityType,
+      state: trailStateForFindings(group),
+      valence: trailValenceForFindings(group, recurrence),
+      confidence: Number(confidence.toFixed(2)),
+      recurrence_score: Math.min(100, recurrence * 28 + evidenceRefs.length * 6),
+      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),
+      recommendation_ids: [],
+      created_at: generatedAt,
+      updated_at: generatedAt,
+      shape: trailShapeForFindings(group, recurrence)
+    };
+  });
+}
+function severityFor(count) {
+  if (count >= 6) return "critical";
+  if (count >= 3) return "high";
+  if (count >= 2) return "medium";
+  return "low";
+}
+function trailsForType(trails, entityType) {
+  return trails.filter((trail) => trail.subject_entity_type === entityType);
+}
+function buildRecurringPatterns(coverage, findings, trails) {
+  const patterns = [];
+  const decisionTrails = trailsForType(trails, "decision");
+  const artifactTrails = trailsForType(trails, "artifact");
+  const blockerTrails = trailsForType(trails, "blocker");
+  const personTrails = trailsForType(trails, "person");
+  const businessTrails = trailsForType(trails, "business");
+  const highRecurrence = trails.filter((trail) => trail.recurrence_score >= 56);
+  if (decisionTrails.length > 0 && !coverage.orgxMcpCalled) {
+    patterns.push({
+      id: "pattern:trapped-decision",
+      title: "Decisions are being made without durable OrgX writeback",
+      description: `${decisionTrails.length} decision trail${decisionTrails.length === 1 ? "" : "s"} appeared while no OrgX MCP write was detected.`,
+      pattern_type: "trapped_decision",
+      affected_trail_ids: decisionTrails.map((trail) => trail.id),
+      affected_entity_ids: decisionTrails.map((trail) => trail.subject_entity_id),
+      recurrence_count: decisionTrails.length,
+      severity: severityFor(decisionTrails.length + 1),
+      confidence: coverage.orgxObserved ? 0.82 : 0.74,
+      valence: "leak",
+      root_cause_hypothesis: "Agents and humans are making useful choices, but the runtime is not promoting those choices into organizational memory.",
+      recommended_runtime_action_id: "recommendation:promote-decisions"
+    });
+  }
+  if (artifactTrails.length > 0 && personTrails.length === 0) {
+    patterns.push({
+      id: "pattern:orphaned-artifact",
+      title: "Artifacts do not have visible ownership",
+      description: `${artifactTrails.length} artifact trail${artifactTrails.length === 1 ? "" : "s"} appeared without a clear owner trail.`,
+      pattern_type: "orphaned_artifact",
+      affected_trail_ids: artifactTrails.map((trail) => trail.id),
+      affected_entity_ids: artifactTrails.map((trail) => trail.subject_entity_id),
+      recurrence_count: artifactTrails.length,
+      severity: severityFor(artifactTrails.length),
+      confidence: 0.72,
+      valence: "risk",
+      root_cause_hypothesis: "Work is becoming concrete, but downstream accountability is not being attached at creation time.",
+      recommended_runtime_action_id: "recommendation:assign-owner"
+    });
+  }
+  if (coverage.missing.length > 0) {
+    const sourceTrails = trailsForType(trails, "source");
+    patterns.push({
+      id: "pattern:missing-source",
+      title: "Important source coverage is missing",
+      description: `Missing sources: ${coverage.missing.join(", ")}.`,
+      pattern_type: "missing_source",
+      affected_trail_ids: sourceTrails.map((trail) => trail.id),
+      affected_entity_ids: sourceTrails.map((trail) => trail.subject_entity_id),
+      recurrence_count: coverage.missing.length,
+      severity: severityFor(coverage.missing.length),
+      confidence: 0.78,
+      valence: "leak",
+      root_cause_hypothesis: "The scan can see work happening, but coordination and proof sources are not fully connected.",
+      recommended_runtime_action_id: "recommendation:connect-source"
+    });
+  }
+  if (coverage.mcpObserved && !coverage.orgxMcpCalled) {
+    patterns.push({
+      id: "pattern:tooling-mismatch",
+      title: "MCP was present, but OrgX was not called",
+      description: "The session mentions MCP/tooling activity, but no durable OrgX MCP call was detected.",
+      pattern_type: "tooling_mismatch",
+      affected_trail_ids: trails.map((trail) => trail.id).slice(0, 6),
+      affected_entity_ids: trails.map((trail) => trail.subject_entity_id).slice(0, 6),
+      recurrence_count: findings.filter((finding) => /\bmcp|tool\b/i.test(finding.summary)).length || 1,
+      severity: "high",
+      confidence: 0.8,
+      valence: "leak",
+      root_cause_hypothesis: "The available tool layer is not automatically closing the loop when work finishes.",
+      recommended_runtime_action_id: "recommendation:install-runtime-hooks"
+    });
+  }
+  if (highRecurrence.length > 0) {
+    patterns.push({
+      id: "pattern:repeated-work",
+      title: "The same work shape is recurring",
+      description: `${highRecurrence.length} trail${highRecurrence.length === 1 ? "" : "s"} repeat strongly enough to deserve durable operating memory.`,
+      pattern_type: "repeated_work",
+      affected_trail_ids: highRecurrence.map((trail) => trail.id),
+      affected_entity_ids: highRecurrence.map((trail) => trail.subject_entity_id),
+      recurrence_count: highRecurrence.reduce((total, trail) => total + trail.events.length, 0),
+      severity: severityFor(highRecurrence.length),
+      confidence: 0.7,
+      valence: "useful_recurrence",
+      root_cause_hypothesis: "Repeated work is creating a reusable operating pattern, but it is still only implicit.",
+      recommended_runtime_action_id: "recommendation:launch-initiative"
+    });
+  }
+  if (businessTrails.length > 0 && findings.every((finding) => finding.type !== "initiative_candidate")) {
+    patterns.push({
+      id: "pattern:business-signal-unclaimed",
+      title: "Business signal has not become a launchable initiative",
+      description: `${businessTrails.length} business trail${businessTrails.length === 1 ? "" : "s"} appeared without a matching initiative candidate.`,
+      pattern_type: "business_signal_unclaimed",
+      affected_trail_ids: businessTrails.map((trail) => trail.id),
+      affected_entity_ids: businessTrails.map((trail) => trail.subject_entity_id),
+      recurrence_count: businessTrails.length,
+      severity: severityFor(businessTrails.length),
+      confidence: 0.68,
+      valence: "opportunity",
+      root_cause_hypothesis: "Revenue or ROI signal exists, but the operating graph has not turned it into an account or initiative loop.",
+      recommended_runtime_action_id: "recommendation:launch-initiative"
+    });
+  }
+  if (blockerTrails.length > 0) {
+    patterns.push({
+      id: "pattern:handoff-friction",
+      title: "Blockers are becoming handoff friction",
+      description: `${blockerTrails.length} blocker trail${blockerTrails.length === 1 ? "" : "s"} need owner-visible resolution.`,
+      pattern_type: "handoff_friction",
+      affected_trail_ids: blockerTrails.map((trail) => trail.id),
+      affected_entity_ids: blockerTrails.map((trail) => trail.subject_entity_id),
+      recurrence_count: blockerTrails.length,
+      severity: severityFor(blockerTrails.length + 1),
+      confidence: 0.76,
+      valence: "risk",
+      root_cause_hypothesis: "Execution is producing unresolved edges that need to become assigned decisions or tasks.",
+      recommended_runtime_action_id: "recommendation:assign-owner"
+    });
+  }
+  return patterns.slice(0, 8);
+}
+function buildTrailRecommendations(patterns, trails) {
+  const recommendations = [];
+  const add = (recommendation) => {
+    if (!recommendations.some((existing) => existing.id === recommendation.id)) {
+      recommendations.push(recommendation);
+    }
+  };
+  for (const pattern of patterns) {
+    const evidenceRefs = sortedUnique(
+      trails.filter((trail) => pattern.affected_trail_ids.includes(trail.id)).flatMap((trail) => trail.evidence_refs)
+    ).slice(0, 8);
+    if (pattern.pattern_type === "trapped_decision") {
+      add({
+        id: "recommendation:promote-decisions",
+        title: "Promote trapped decisions",
+        summary: "Turn inferred decisions into reviewed OrgX decision records with owners and downstream artifact links.",
+        action_type: "promote_decision",
+        trail_ids: pattern.affected_trail_ids,
+        evidence_refs: evidenceRefs,
+        priority: pattern.severity === "critical" || pattern.severity === "high" ? "p0" : "p1",
+        expected_lift: "+decision durability",
+        confidence: pattern.confidence
+      });
+    } else if (pattern.pattern_type === "orphaned_artifact") {
+      add({
+        id: "recommendation:assign-owner",
+        title: "Assign ownership to orphaned artifacts",
+        summary: "Attach owners and next actions to artifacts before they decay into unqueryable receipts.",
+        action_type: "assign_owner",
+        trail_ids: pattern.affected_trail_ids,
+        evidence_refs: evidenceRefs,
+        priority: "p1",
+        expected_lift: "+owner clarity",
+        confidence: pattern.confidence
+      });
+    } else if (pattern.pattern_type === "missing_source") {
+      add({
+        id: "recommendation:connect-source",
+        title: "Connect missing source coverage",
+        summary: "Close the evidence gap by connecting the coordination or proof sources where trails terminate.",
+        action_type: "connect_source",
+        trail_ids: pattern.affected_trail_ids,
+        evidence_refs: evidenceRefs,
+        priority: "p1",
+        expected_lift: "+source confidence",
+        confidence: pattern.confidence
+      });
+    } else if (pattern.pattern_type === "tooling_mismatch") {
+      add({
+        id: "recommendation:install-runtime-hooks",
+        title: "Install runtime writeback hooks",
+        summary: "Use post-session reconciliation so useful work becomes OrgX activity even when the agent forgets.",
+        action_type: "verify_outcome",
+        trail_ids: pattern.affected_trail_ids,
+        evidence_refs: evidenceRefs,
+        priority: "p0",
+        expected_lift: "+continuous attribution",
+        confidence: pattern.confidence
+      });
+    } else if (pattern.pattern_type === "business_signal_unclaimed" || pattern.pattern_type === "repeated_work") {
+      add({
+        id: "recommendation:launch-initiative",
+        title: "Launch from this trail",
+        summary: "Convert the highest-recurring evidence path into an OrgX initiative with proof requirements.",
+        action_type: "launch_initiative",
+        trail_ids: pattern.affected_trail_ids,
+        evidence_refs: evidenceRefs,
+        priority: pattern.severity === "critical" || pattern.severity === "high" ? "p0" : "p1",
+        expected_lift: "+initiative readiness",
+        confidence: pattern.confidence
+      });
+    }
+  }
+  if (recommendations.length === 0 && trails.length > 0) {
+    const topTrail = [...trails].sort((a, b) => b.impact_score - a.impact_score)[0];
+    add({
+      id: "recommendation:inspect-top-trail",
+      title: "Inspect the strongest trail",
+      summary: "Review the highest-confidence evidence path and decide whether it should become durable OrgX memory.",
+      action_type: "launch_initiative",
+      trail_ids: [topTrail.id],
+      evidence_refs: topTrail.evidence_refs,
+      priority: "p2",
+      expected_lift: "+operating memory",
+      confidence: topTrail.confidence
+    });
+  }
+  return recommendations.slice(0, 5);
+}
+function buildWorkGraphMirror(input) {
+  const { coverage, generatedAt, patterns, recommendations, trails } = input;
+  const topTrail = [...trails].sort((a, b) => b.impact_score - a.impact_score)[0];
+  const 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 primaryClaimRefs = topTrail?.evidence_refs ?? [];
+  const claims = [
+    {
+      id: "mirror:trail-count",
+      text: `${trails.length} trails were detected across ${coverage.connected.length} connected source${coverage.connected.length === 1 ? "" : "s"}.`,
+      evidence_refs: trails.flatMap((trail) => trail.evidence_refs).slice(0, 6),
+      confidence: trails.length > 0 ? 0.82 : 0.55
+    },
+    {
+      id: "mirror:decision-artifact-balance",
+      text: `${decisionCount} decision trail${decisionCount === 1 ? "" : "s"} and ${artifactCount} artifact trail${artifactCount === 1 ? "" : "s"} were found.`,
+      evidence_refs: trails.filter((trail) => trail.subject_entity_type === "decision" || trail.subject_entity_type === "artifact").flatMap((trail) => trail.evidence_refs).slice(0, 6),
+      confidence: 0.78
+    },
+    {
+      id: "mirror:missing-sources",
+      text: sourceGapCount > 0 ? `${sourceGapCount} source gap${sourceGapCount === 1 ? "" : "s"} still limit attribution depth.` : "The connected sources are enough for a first operating profile.",
+      evidence_refs: trailsForType(trails, "source").flatMap((trail) => trail.evidence_refs).slice(0, 4),
+      confidence: sourceGapCount > 0 ? 0.76 : 0.66
+    }
+  ];
+  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(" ");
+  return {
+    headline,
+    body,
+    lens: "all",
+    claims,
+    ...topTrail ? { primary_trail_id: topTrail.id } : {},
+    generated_at: generatedAt
+  };
+}
+function buildTensionMetrics(input) {
+  const { coverage, patterns, 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 [
+    {
+      id: "tension:work-leaks",
+      label: "work leaks",
+      value: String(patterns.filter((pattern) => pattern.valence === "leak" || pattern.valence === "risk").length),
+      tone: patterns.some((pattern) => pattern.severity === "critical" || pattern.severity === "high") ? "danger" : "warning",
+      trail_ids: patterns.flatMap((pattern) => pattern.affected_trail_ids).slice(0, 8),
+      evidence_refs: trails.flatMap((trail) => trail.evidence_refs).slice(0, 8),
+      explanation: "Patterns where evidence exists but ownership, source coverage, or writeback is incomplete."
+    },
+    {
+      id: "tension:decisions-decaying",
+      label: "decisions decaying",
+      value: String(decisionTrails.filter((trail) => trail.state === "inferred" || trail.state === "missing_evidence").length),
+      tone: decisionTrails.length > 0 && !coverage.orgxMcpCalled ? "danger" : "muted",
+      trail_ids: decisionTrails.map((trail) => trail.id),
+      evidence_refs: decisionTrails.flatMap((trail) => trail.evidence_refs).slice(0, 8),
+      explanation: "Decision trails that have not been promoted into durable OrgX records."
+    },
+    {
+      id: "tension:artifacts-orphaned",
+      label: "artifacts orphaned",
+      value: String(artifactTrails.filter((trail) => trail.state !== "verified").length),
+      tone: artifactTrails.some((trail) => trail.shape === "artifact_heavy_decision_light") ? "warning" : "muted",
+      trail_ids: artifactTrails.map((trail) => trail.id),
+      evidence_refs: artifactTrails.flatMap((trail) => trail.evidence_refs).slice(0, 8),
+      explanation: "Artifacts that exist without complete decision, verification, or owner context."
+    },
+    {
+      id: "tension:sources-missing",
+      label: "sources missing",
+      value: String(coverage.missing.length),
+      tone: coverage.missing.length > 0 ? "warning" : "good",
+      trail_ids: missingSourceTrails.map((trail) => trail.id),
+      evidence_refs: missingSourceTrails.flatMap((trail) => trail.evidence_refs).slice(0, 6),
+      explanation: "Disconnected coordination or proof sources that limit attribution confidence."
+    },
+    {
+      id: "tension:launch-ready",
+      label: "launch ready",
+      value: String(topReady.length),
+      tone: topReady.length > 0 && blockerTrails.length === 0 ? "good" : "muted",
+      trail_ids: topReady.map((trail) => trail.id).slice(0, 6),
+      evidence_refs: topReady.flatMap((trail) => trail.evidence_refs).slice(0, 8),
+      explanation: "High-confidence trails that can become initiatives, decisions, artifacts, or owner-visible follow-ups."
+    }
+  ];
+}
+function countFindingsByType(findings) {
+  const counts = {};
+  for (const finding of findings) {
+    counts[finding.type] = (counts[finding.type] ?? 0) + 1;
+  }
+  return Object.fromEntries(
+    Object.entries(counts).sort(([left], [right]) => left.localeCompare(right))
+  );
+}
+function buildWorkGraphFingerprint(input) {
+  const sourceClients = sortedUnique(input.findings.map((finding) => finding.source_client));
+  const patternHashes = input.findings.map(
+    (finding) => shortHash({
+      type: finding.type,
+      title: normalizeFingerprintText(finding.title),
+      summary: normalizeFingerprintText(finding.summary),
+      source_client: finding.source_client
+    })
+  ).sort();
+  const kickoffHashes = input.kickoffs.map(
+    (kickoff) => shortHash({
+      title: normalizeFingerprintText(kickoff.title),
+      summary: normalizeFingerprintText(kickoff.summary),
+      priority: kickoff.priority
+    })
+  ).sort();
+  const trailShapeHashes = input.trails.map(
+    (trail) => shortHash({
+      kind: trail.kind,
+      subject_entity_type: trail.subject_entity_type,
+      state: trail.state,
+      valence: trail.valence,
+      shape: trail.shape,
+      title: normalizeFingerprintText(trail.title)
+    })
+  ).sort();
+  const recurringPatternHashes = input.recurringPatterns.map(
+    (pattern) => shortHash({
+      pattern_type: pattern.pattern_type,
+      severity: pattern.severity,
+      title: normalizeFingerprintText(pattern.title),
+      recurrence_count: pattern.recurrence_count
+    })
+  ).sort();
+  const basis = {
+    schema_version: WORK_GRAPH_SCHEMA_VERSION,
+    fingerprint_version: WORK_GRAPH_FINGERPRINT_VERSION,
+    workspace_hash: shortHash({
+      id: normalizeFingerprintText(input.workspace.id),
+      name: normalizeFingerprintText(input.workspace.name)
+    }),
+    source_clients: sourceClients,
+    connected_source_hashes: sortedUnique(
+      input.connectedSources.map((source) => shortHash(normalizeFingerprintText(source)))
+    ),
+    missing_source_hashes: sortedUnique(
+      input.missingSources.map((source) => shortHash(normalizeFingerprintText(source)))
+    ),
+    finding_type_counts: countFindingsByType(input.findings),
+    pattern_hashes: patternHashes,
+    trail_shape_hashes: trailShapeHashes,
+    recurring_pattern_hashes: recurringPatternHashes,
+    kickoff_hashes: kickoffHashes,
+    raw_transcripts_included: false
+  };
+  const fingerprint = `wgf_${hashJson(basis).slice(0, 24)}`;
+  return {
+    fingerprint,
+    basis,
+    hydration: {
+      strategy: "work_graph_fingerprint_claim",
+      hydration_key: `orgx:work-graph:${fingerprint}`,
+      eligible: input.findings.length > 0,
+      notes: [
+        "Use this fingerprint to claim the pre-signup Work Graph after account creation.",
+        "The fingerprint is derived from normalized patterns, source coverage, and kickoff shapes, not raw transcripts."
+      ]
+    }
+  };
+}
+function buildSessionReconciliationReport(input) {
+  if (input.imports.length === 0) {
+    throw new Error("At least one source import is required to build a Work Graph report.");
+  }
+  const generatedAt = input.generatedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+  const connectedSources = input.connectedSources ?? input.imports.map((source) => source.sourceLabel);
+  const missingSources = input.missingSources ?? [];
+  const coverage = buildCoverage(input.imports, connectedSources, missingSources);
+  const events = buildWorkGraphEvents(input.imports);
+  const findings = buildWorkGraphFindings(input.imports);
+  const missed = buildMissedOpportunities(coverage, findings);
+  const allFindings = [...findings, ...missed];
+  const trails = buildWorkGraphTrails(allFindings, generatedAt);
+  const recurringPatterns = buildRecurringPatterns(coverage, allFindings, trails);
+  const opportunityScore = scoreOpportunity(coverage, allFindings);
+  const initiativeKickoffs = buildKickoffs(allFindings, missed, opportunityScore);
+  const recommendations = buildTrailRecommendations(recurringPatterns, trails);
+  const mirror = buildWorkGraphMirror({
+    coverage,
+    generatedAt,
+    patterns: recurringPatterns,
+    recommendations,
+    trails
+  });
+  const tensionMetrics = buildTensionMetrics({
+    coverage,
+    patterns: recurringPatterns,
+    trails
+  });
+  const fingerprint = buildWorkGraphFingerprint({
+    connectedSources,
+    findings: allFindings,
+    kickoffs: initiativeKickoffs,
+    missingSources,
+    recurringPatterns,
+    trails,
+    workspace: input.workspace
+  });
+  const reportSeed = {
+    generatedAt,
+    imports: input.imports.map((source) => ({
+      sourceId: source.sourceId,
+      textHash: hashJson(source.text)
+    })),
+    workspace: input.workspace
+  };
+  const reportHash = hashJson(reportSeed);
+  const sessionId = input.sessionId ?? `work-graph-${reportHash.slice(0, 16)}`;
+  return {
+    schema_version: WORK_GRAPH_SCHEMA_VERSION,
+    report_id: reportHash.slice(0, 24),
+    idempotency_key: `work-graph:${sessionId}:${reportHash.slice(0, 16)}`,
+    work_graph_fingerprint: fingerprint.fingerprint,
+    fingerprint_version: WORK_GRAPH_FINGERPRINT_VERSION,
+    fingerprint_basis: fingerprint.basis,
+    signup_hydration: fingerprint.hydration,
+    generated_at: generatedAt,
+    source_client: "wizard",
+    session_id: sessionId,
+    workspace: input.workspace,
+    source_coverage: coverage,
+    final_state: inferFinalState(allFindings),
+    events,
+    findings: allFindings,
+    missed_orchestration_opportunities: missed,
+    trails,
+    recurring_patterns: recurringPatterns,
+    recommendations,
+    mirror,
+    tension_metrics: tensionMetrics,
+    opportunity_score: opportunityScore,
+    initiative_kickoffs: initiativeKickoffs,
+    redaction_level: "summary_only",
+    raw_transcripts_sent: false
+  };
+}
+function renderWorkGraphMarkdown(report) {
+  const lines = [];
+  lines.push("# OrgX Work Graph Reconciliation");
+  lines.push("");
+  lines.push(`Generated: ${report.generated_at}`);
+  lines.push(`Workspace: ${report.workspace.name} (${report.workspace.id})`);
+  lines.push(`Report ID: ${report.report_id}`);
+  lines.push(`Work graph fingerprint: ${report.work_graph_fingerprint}`);
+  lines.push(`Hydration key: ${report.signup_hydration.hydration_key}`);
+  lines.push(`Final state: ${report.final_state}`);
+  lines.push("");
+  lines.push("## Opportunity Score");
+  lines.push("");
+  lines.push(`Overall: ${report.opportunity_score.overall}/100`);
+  lines.push(`Value potential: ${report.opportunity_score.value_potential}/100`);
+  lines.push(`Evidence quality: ${report.opportunity_score.evidence_quality}/100`);
+  lines.push(`Urgency: ${report.opportunity_score.urgency}/100`);
+  lines.push(`Owner clarity: ${report.opportunity_score.owner_clarity}/100`);
+  lines.push(`Automation potential: ${report.opportunity_score.automation_potential}/100`);
+  lines.push(`OrgX fit: ${report.opportunity_score.orgx_fit}/100`);
+  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(`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"}`);
+  lines.push("");
+  lines.push("## Mirror");
+  lines.push("");
+  lines.push(`### ${report.mirror.headline}`);
+  lines.push("");
+  lines.push(report.mirror.body);
+  lines.push("");
+  for (const claim of report.mirror.claims) {
+    lines.push(`- ${claim.text} (${claim.evidence_refs.join(", ") || "no evidence refs"})`);
+  }
+  lines.push("");
+  lines.push("## Live Tension");
+  lines.push("");
+  for (const metric of report.tension_metrics) {
+    lines.push(`- ${metric.value} ${metric.label}: ${metric.explanation}`);
+  }
+  lines.push("");
+  lines.push("## Work Graph Trails");
+  lines.push("");
+  for (const trail of report.trails.slice(0, 12)) {
+    lines.push(`- [${trail.kind}] ${trail.title} \u2014 ${trail.state}, ${trail.valence}, ${trail.shape} (${trail.evidence_refs.join(", ")})`);
+  }
+  lines.push("");
+  lines.push("## Recurring Patterns");
+  lines.push("");
+  if (report.recurring_patterns.length === 0) {
+    lines.push("- No recurring patterns detected yet.");
+  } else {
+    for (const pattern of report.recurring_patterns) {
+      lines.push(`- [${pattern.severity}] ${pattern.title}: ${pattern.root_cause_hypothesis}`);
+    }
+  }
+  lines.push("");
+  lines.push("## Top Findings");
+  lines.push("");
+  for (const finding of report.findings.slice(0, 12)) {
+    lines.push(`- [${finding.type}] ${finding.title} (${finding.evidence_ref})`);
+  }
+  lines.push("");
+  lines.push("## Missed Orchestration");
+  lines.push("");
+  if (report.missed_orchestration_opportunities.length === 0) {
+    lines.push("- No missed orchestration opportunities detected.");
+  } else {
+    for (const finding of report.missed_orchestration_opportunities) {
+      lines.push(`- ${finding.title}: ${finding.summary}`);
+    }
+  }
+  lines.push("");
+  lines.push("## Initiative Kickoffs");
+  lines.push("");
+  for (const kickoff of report.initiative_kickoffs) {
+    lines.push(`- [${kickoff.priority}] ${kickoff.title}: ${kickoff.summary}`);
+  }
+  lines.push("");
+  lines.push("## Eject Bay Recommendations");
+  lines.push("");
+  for (const recommendation of report.recommendations) {
+    lines.push(`- [${recommendation.priority}] ${recommendation.title}: ${recommendation.summary}`);
+  }
+  lines.push("");
+  lines.push("## Signup Hydration");
+  lines.push("");
+  lines.push(`- Strategy: ${report.signup_hydration.strategy}`);
+  lines.push(`- Eligible: ${report.signup_hydration.eligible ? "yes" : "no"}`);
+  for (const note of report.signup_hydration.notes) {
+    lines.push(`- ${note}`);
+  }
+  lines.push("");
+  lines.push("## Privacy");
+  lines.push("");
+  lines.push("- Raw transcripts were not sent.");
+  lines.push("- This report contains summaries, hashes, and evidence refs only.");
+  return lines.join("\n");
+}
+
+// src/lib/runtime-hooks.ts
+import { copyFileSync, existsSync as existsSync6, 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";
+var HOOK_EVENTS = ["SessionStart", "UserPromptSubmit", "PreToolUse", "PostToolUse", "PermissionRequest", "Stop"];
+var CLAUDE_HOOK_EVENTS = ["SessionStart", "UserPromptSubmit", "PreToolUse", "PostToolUse", "SubagentStop", "Stop", "SessionEnd"];
+function defaultPaths(options = {}) {
+  const hookDir = join5(ORGX_WIZARD_CONFIG_HOME, "hooks");
+  return {
+    claudeSettingsPath: options.claudeSettingsPath ?? join5(CLAUDE_DIR, "settings.json"),
+    codexConfigPath: options.codexConfigPath ?? CODEX_CONFIG_PATH ?? join5(CODEX_DIR, "config.toml"),
+    codexHooksPath: options.codexHooksPath ?? join5(CODEX_DIR, "hooks.json"),
+    hookScriptPath: options.hookScriptPath ?? join5(hookDir, HOOK_MARKER),
+    outboxPath: options.outboxPath ?? join5(hookDir, "events.jsonl")
+  };
+}
+function countJsonlLines(path) {
+  const raw = readTextIfExists(path);
+  if (!raw) return 0;
+  return raw.split(/\r?\n/).filter((line) => line.trim().length > 0).length;
+}
+function backupPath(path, now) {
+  const timestamp = now.toISOString().replace(/[:.]/g, "-");
+  return `${path}.bak.${timestamp}`;
+}
+function backupExisting(path, now) {
+  if (!existsSync6(path)) return null;
+  const backup = backupPath(path, now);
+  copyFileSync(path, backup);
+  return backup;
+}
+function hasOrgxHook(raw) {
+  return Boolean(raw?.includes(HOOK_MARKER));
+}
+function codexHooksEnabled(raw) {
+  return Boolean(raw && /^\s*codex_hooks\s*=\s*true\s*$/m.test(raw));
+}
+function codexHasNotify(raw) {
+  return Boolean(raw && /^\s*notify\s*=/m.test(raw));
+}
+function buildRuntimeHookScriptContent() {
+  return `#!/usr/bin/env node
+import { appendFileSync, mkdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { homedir } from "node:os";
+
+function parseArgs(argv) {
+  const args = {};
+  for (const arg of argv) {
+    if (!arg.startsWith("--")) continue;
+    const [key, ...rest] = arg.slice(2).split("=");
+    args[key] = rest.length > 0 ? rest.join("=") : "true";
+  }
+  return args;
+}
+
+function pickString(...values) {
+  for (const value of values) {
+    if (typeof value !== "string") continue;
+    const trimmed = value.trim();
+    if (trimmed) return trimmed;
+  }
+  return undefined;
+}
+
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) chunks.push(Buffer.from(chunk));
+  return Buffer.concat(chunks).toString("utf8");
+}
+
+function parseJson(value) {
+  try {
+    const parsed = JSON.parse(value || "{}");
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+function summarize(payload) {
+  const toolName = pickString(payload.tool_name, payload.toolName, payload.tool?.name, payload.name);
+  const prompt = pickString(payload.prompt);
+  return {
+    tool_name: toolName,
+    prompt_chars: prompt ? prompt.length : undefined,
+    payload_keys: Object.keys(payload).slice(0, 40),
+  };
+}
+
+const args = parseArgs(process.argv.slice(2));
+const raw = await readStdin();
+const payload = parseJson(raw);
+const outbox = pickString(
+  process.env.ORGX_WIZARD_HOOK_OUTBOX,
+  args.outbox,
+  join(homedir(), ".config", "useorgx", "wizard", "hooks", "events.jsonl")
+);
+const event = pickString(args.event, payload.hook_event_name, payload.hookEventName, payload.event, payload.eventName, "unknown");
+const sourceClient = pickString(args.source_client, args["source-client"], "unknown");
+
+const record = {
+  schema_version: "2026-05-07",
+  source: "orgx_wizard_runtime_hook",
+  source_client: sourceClient,
+  event,
+  session_id: pickString(payload.session_id, payload.sessionId, payload.conversation_id, payload.conversationId),
+  turn_id: pickString(payload.turn_id, payload.turnId),
+  cwd: pickString(payload.cwd, payload.working_directory, payload.workspace, process.cwd()),
+  transcript_path: pickString(payload.transcript_path, payload.transcriptPath),
+  timestamp: new Date().toISOString(),
+  summary: summarize(payload),
+};
+
+try {
+  mkdirSync(dirname(outbox), { recursive: true, mode: 0o700 });
+  appendFileSync(outbox, JSON.stringify(record) + "\\n", { encoding: "utf8", mode: 0o600 });
+} catch {
+  // Hooks must never break the user's agent runtime.
+}
+
+process.exit(0);
+`;
+}
+function buildHookCommand(params) {
+  return [
+    "node",
+    JSON.stringify(params.hookScriptPath),
+    `--event=${params.event}`,
+    `--source_client=${params.sourceClient}`,
+    `--outbox=${params.outboxPath}`
+  ].join(" ");
+}
+function mergeCodexHooks(raw, paths) {
+  const value = parseJsonObject(raw);
+  const hooks = isRecord(value.hooks) ? value.hooks : {};
+  let changed = false;
+  for (const event of HOOK_EVENTS) {
+    const existing = Array.isArray(hooks[event]) ? hooks[event] : [];
+    const command = buildHookCommand({
+      event,
+      hookScriptPath: paths.hookScriptPath,
+      outboxPath: paths.outboxPath,
+      sourceClient: "codex"
+    });
+    const already = existing.some(
+      (entry) => isRecord(entry) && typeof entry.command === "string" && entry.command.includes(HOOK_MARKER)
+    );
+    if (!already) {
+      hooks[event] = [...existing, { command }];
+      changed = true;
+    }
+  }
+  value.hooks = hooks;
+  return { changed: changed || !raw, value };
+}
+function mergeClaudeHooks(raw, paths) {
+  const value = parseJsonObject(raw);
+  const hooksRoot = isRecord(value.hooks) ? value.hooks : {};
+  let changed = false;
+  for (const event of CLAUDE_HOOK_EVENTS) {
+    const list = Array.isArray(hooksRoot[event]) ? hooksRoot[event] : [];
+    const matcher = event === "PreToolUse" || event === "PostToolUse" ? "Bash|Write|Edit|MultiEdit|mcp__.*" : "";
+    const command = buildHookCommand({
+      event,
+      hookScriptPath: paths.hookScriptPath,
+      outboxPath: paths.outboxPath,
+      sourceClient: "claude-code"
+    });
+    let rule = list.find((entry) => isRecord(entry) && entry.matcher === matcher);
+    if (!rule) {
+      rule = { matcher, hooks: [] };
+      list.push(rule);
+      changed = true;
+    }
+    const hooks = Array.isArray(rule.hooks) ? rule.hooks : [];
+    const already = hooks.some(
+      (entry) => isRecord(entry) && entry.type === "command" && typeof entry.command === "string" && entry.command.includes(HOOK_MARKER)
+    );
+    if (!already) {
+      hooks.push({ type: "command", command });
+      rule.hooks = hooks;
+      changed = true;
+    }
+    hooksRoot[event] = list;
+  }
+  value.hooks = hooksRoot;
+  return { changed: changed || !raw, value };
+}
+function ensureCodexHooksFeature(raw) {
+  const current = raw ?? "";
+  if (codexHooksEnabled(current)) {
+    return { changed: false, value: current };
+  }
+  if (/^\s*codex_hooks\s*=\s*false\s*$/m.test(current)) {
+    return {
+      changed: true,
+      value: current.replace(/^\s*codex_hooks\s*=\s*false\s*$/m, "codex_hooks = true")
+    };
+  }
+  if (/^\s*\[features\]\s*$/m.test(current)) {
+    return {
+      changed: true,
+      value: current.replace(/^(\s*\[features\]\s*)$/m, "$1\ncodex_hooks = true")
+    };
+  }
+  const suffix = current.trimEnd().length > 0 ? "\n\n" : "";
+  return {
+    changed: true,
+    value: `${current.trimEnd()}${suffix}[features]
+codex_hooks = true
+`
+  };
+}
+function inspectRuntimeHooks(options = {}) {
+  const paths = defaultPaths(options);
+  const codexConfigRaw = readTextIfExists(paths.codexConfigPath);
+  const codexHooksRaw = readTextIfExists(paths.codexHooksPath);
+  const claudeSettingsRaw = readTextIfExists(paths.claudeSettingsPath);
+  return {
+    paths,
+    installed: {
+      claudeCode: hasOrgxHook(claudeSettingsRaw),
+      codex: hasOrgxHook(codexHooksRaw),
+      hookScript: existsSync6(paths.hookScriptPath)
+    },
+    codex: {
+      configExists: Boolean(codexConfigRaw),
+      hooksEnabled: codexHooksEnabled(codexConfigRaw),
+      hasNotify: codexHasNotify(codexConfigRaw),
+      notifyPreserved: !codexHasNotify(codexConfigRaw) || !hasOrgxHook(codexConfigRaw)
+    },
+    outboxEvents: countJsonlLines(paths.outboxPath)
+  };
+}
+function installRuntimeHooks(targets, options = {}) {
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const paths = defaultPaths(options);
+  const backups = [];
+  const changed = {
+    claudeCode: false,
+    codex: false,
+    codexConfig: false,
+    hookScript: false
+  };
+  mkdirSync3(dirname4(paths.hookScriptPath), { recursive: true, mode: 448 });
+  const scriptContent = buildRuntimeHookScriptContent();
+  if (readTextIfExists(paths.hookScriptPath) !== scriptContent) {
+    const backup = backupExisting(paths.hookScriptPath, now);
+    if (backup) backups.push(backup);
+    writeTextFile(paths.hookScriptPath, scriptContent, { mode: 448 });
+    changed.hookScript = true;
+  }
+  if (targets.includes("codex")) {
+    const rawConfig = readTextIfExists(paths.codexConfigPath);
+    const nextConfig = ensureCodexHooksFeature(rawConfig);
+    if (nextConfig.changed) {
+      const backup = backupExisting(paths.codexConfigPath, now);
+      if (backup) backups.push(backup);
+      writeTextFile(paths.codexConfigPath, nextConfig.value, { mode: 384 });
+      changed.codexConfig = true;
+    }
+    const rawHooks = readTextIfExists(paths.codexHooksPath);
+    const nextHooks = mergeCodexHooks(rawHooks, paths);
+    if (nextHooks.changed) {
+      const backup = backupExisting(paths.codexHooksPath, now);
+      if (backup) backups.push(backup);
+      writeJsonFile(paths.codexHooksPath, nextHooks.value, { mode: 384 });
+      changed.codex = true;
+    }
+  }
+  if (targets.includes("claude-code")) {
+    const rawSettings = readTextIfExists(paths.claudeSettingsPath);
+    const nextSettings = mergeClaudeHooks(rawSettings, paths);
+    if (nextSettings.changed) {
+      const backup = backupExisting(paths.claudeSettingsPath, now);
+      if (backup) backups.push(backup);
+      writeJsonFile(paths.claudeSettingsPath, nextSettings.value, { mode: 384 });
+      changed.claudeCode = true;
+    }
+  }
+  return {
+    ...inspectRuntimeHooks(options),
+    changed,
+    backups
+  };
+}
+function parseRuntimeHookTargets(value) {
+  if (!value?.trim()) return ["codex", "claude-code"];
+  const requested = value.split(",").map((item) => item.trim().toLowerCase()).filter(Boolean);
+  const expanded = requested.includes("all") ? ["codex", "claude-code"] : requested;
+  const normalized = expanded.map((target) => {
+    if (target === "claude" || target === "claude_code") return "claude-code";
+    return target;
+  });
+  const invalid = normalized.filter((target) => target !== "codex" && target !== "claude-code");
+  if (invalid.length > 0) {
+    throw new Error(`Unsupported hook target: ${invalid.join(", ")}. Use codex, claude-code, or all.`);
+  }
+  return [...new Set(normalized)];
+}
+
 // src/spinner.ts
 import ora from "ora";
 import pc2 from "picocolors";
@@ -6992,12 +8324,31 @@ function printPluginMutationReport(report) {
 function formatScoreLine(scores) {
   return Object.entries(scores).map(([dimension, score]) => `${dimension}=${score}`).join(" ");
 }
+function formatWorkGraphScoreLine(score) {
+  return [
+    `overall=${score.overall}`,
+    `value=${score.value_potential}`,
+    `evidence=${score.evidence_quality}`,
+    `urgency=${score.urgency}`,
+    `owner=${score.owner_clarity}`,
+    `automation=${score.automation_potential}`,
+    `orgx_fit=${score.orgx_fit}`
+  ].join(" ");
+}
+function printRuntimeHookInspection(report) {
+  console.log(`  ${report.installed.hookScript ? ICON.ok : ICON.warn}  ${pc3.bold("hook script  ")} ${report.installed.hookScript ? pc3.green("installed") : pc3.yellow("missing")}  ${pc3.dim(report.paths.hookScriptPath)}`);
+  console.log(`  ${report.installed.codex ? ICON.ok : ICON.warn}  ${pc3.bold("Codex       ")} ${report.installed.codex ? pc3.green("installed") : pc3.yellow("missing")}  ${pc3.dim(report.paths.codexHooksPath)}`);
+  console.log(`  ${report.codex.hooksEnabled ? ICON.ok : ICON.warn}  ${pc3.bold("Codex flag  ")} ${report.codex.hooksEnabled ? pc3.green("enabled") : pc3.yellow("not enabled")}  ${pc3.dim(report.paths.codexConfigPath)}`);
+  console.log(`  ${report.codex.notifyPreserved ? ICON.ok : ICON.warn}  ${pc3.bold("notify      ")} ${report.codex.notifyPreserved ? pc3.green("preserved") : pc3.yellow("check config")}  ${pc3.dim(report.codex.hasNotify ? "existing notify detected" : "no notify entry")}`);
+  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 readAuditInput(options, interactive) {
   if (options.input?.trim()) {
-    return readFileSync4(resolve(options.input.trim()), "utf8");
+    return readFileSync5(resolve(options.input.trim()), "utf8");
   }
   if (!process.stdin.isTTY) {
-    return readFileSync4(0, "utf8");
+    return readFileSync5(0, "utf8");
   }
   if (!interactive) {
     throw new Error("Audit input is required. Pass --input <file> or pipe text into wizard audit.");
@@ -7171,6 +8522,70 @@ async function runAuditCommand(options) {
     console.log(`  ${ICON.ok}  ${pc3.green("follow-up     ")} ${pc3.bold(followUp.title)} ${pc3.dim(followUp.id)}`);
   }
 }
+async function runWorkGraphCommand(options, defaults = {}) {
+  const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY);
+  const commandOptions = {
+    ...options,
+    ...options.from?.trim() ? {} : defaults.from ? { from: defaults.from } : {}
+  };
+  const auditImports = await readAuditImports(commandOptions, interactive);
+  const workspace = await resolveAuditWorkspace(commandOptions);
+  const report = buildSessionReconciliationReport({
+    connectedSources: [
+      ...auditImports.connectedSources,
+      ...workspace.id === "local-workspace" ? [] : ["OrgX workspace"]
+    ],
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    imports: auditImports.imports,
+    missingSources: [
+      ...workspace.id === "local-workspace" ? ["OrgX workspace auth"] : [],
+      ...auditImports.missingSources
+    ],
+    workspace
+  });
+  const markdown = renderWorkGraphMarkdown(report);
+  const outputDir = resolve(commandOptions.outputDir?.trim() || ".orgx/work-graph");
+  const timestamp = report.generated_at.replace(/[:.]/g, "-");
+  const jsonPath = resolve(outputDir, `work-graph-report-${timestamp}.json`);
+  const markdownPath = resolve(outputDir, `work-graph-report-${timestamp}.md`);
+  writeJsonFile(jsonPath, report);
+  writeTextFile(markdownPath, markdown);
+  if (commandOptions.json) {
+    console.log(JSON.stringify({
+      jsonPath,
+      markdownPath,
+      reportId: report.report_id,
+      workGraphFingerprint: report.work_graph_fingerprint,
+      hydrationKey: report.signup_hydration.hydration_key,
+      finalState: report.final_state,
+      opportunityScore: report.opportunity_score,
+      missedOrchestration: report.missed_orchestration_opportunities.length,
+      kickoffCount: report.initiative_kickoffs.length,
+      trailCount: report.trails.length,
+      recurringPatternCount: report.recurring_patterns.length,
+      topTrail: report.mirror.primary_trail_id ?? null,
+      mirrorHeadline: report.mirror.headline
+    }, null, 2));
+    return;
+  }
+  console.log(`  ${ICON.ok}  ${pc3.green("work graph    ")} ${pc3.dim(markdownPath)}`);
+  console.log(`  ${ICON.ok}  ${pc3.green("report id     ")} ${pc3.dim(report.report_id)}`);
+  console.log(`  ${ICON.ok}  ${pc3.green("fingerprint   ")} ${pc3.dim(report.work_graph_fingerprint)}`);
+  console.log(`  ${ICON.ok}  ${pc3.green("state         ")} ${pc3.dim(report.final_state)}`);
+  console.log(`  ${ICON.ok}  ${pc3.green("score         ")} ${pc3.dim(formatWorkGraphScoreLine(report.opportunity_score))}`);
+  const missed = report.missed_orchestration_opportunities.length;
+  const missedColor = missed > 0 ? pc3.yellow : pc3.green;
+  console.log(`  ${missed > 0 ? ICON.warn : ICON.ok}  ${missedColor("missed        ")} ${pc3.dim(`${missed} orchestration opportunit${missed === 1 ? "y" : "ies"}`)}`);
+  console.log(`  ${ICON.ok}  ${pc3.green("trails        ")} ${pc3.dim(`${report.trails.length} trail${report.trails.length === 1 ? "" : "s"} \xB7 ${report.recurring_patterns.length} recurring pattern${report.recurring_patterns.length === 1 ? "" : "s"}`)}`);
+  console.log(`  ${ICON.skip}  ${pc3.bold("mirror       ")} ${report.mirror.headline}`);
+  for (const metric of report.tension_metrics.slice(0, 4)) {
+    const tone = metric.tone === "danger" ? pc3.red : metric.tone === "warning" ? pc3.yellow : metric.tone === "good" ? pc3.green : pc3.dim;
+    console.log(`  ${ICON.skip}  ${tone(`${metric.value} ${metric.label}`)} ${pc3.dim(metric.explanation)}`);
+  }
+  for (const kickoff of report.initiative_kickoffs) {
+    console.log(`  ${ICON.skip}  ${pc3.bold(kickoff.priority.padEnd(3))} ${kickoff.title}`);
+  }
+}
 async function checkPluginStatusesCompact() {
   const spinner = createOrgxSpinner("Checking OrgX companion plugin status");
   spinner.start();
@@ -8129,7 +9544,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.26" : void 0;
+  const pkgVersion = true ? "0.1.28" : void 0;
   program.version(pkgVersion ?? "unknown", "-V, --version");
   program.hook("preAction", () => {
     console.log(renderBanner(pkgVersion));
@@ -8828,6 +10243,66 @@ async function main() {
     });
     await runAuditCommand(options);
   });
+  const workGraph = program.command("work-graph").description("Build a redacted OrgX Work Graph report from AI-client, Slack, MCP, or manual context.");
+  workGraph.command("preview").description("Preview the live Work Graph opportunity map without writing to OrgX.").option("--input <path>", "source transcript or summary file; stdin is used when piped").option("--from <sources>", "auto-import recent local AI sessions: codex, claude, or all").option("--session-limit <count>", "max recent sessions to import per selected source", "3").option("--session-days <days>", "lookback window for local AI-session imports", "30").option("--codex-sessions-dir <path>", "override Codex sessions directory for import").option("--claude-projects-dir <path>", "override Claude projects directory for import").option("--source-label <label>", "label for the imported manual source").option("--workspace-id <id>", "workspace id override; defaults to the current OrgX workspace when authenticated").option("--workspace-name <name>", "workspace name override for local-only previews").option("--output-dir <path>", "directory for generated Work Graph JSON and Markdown", ".orgx/work-graph").option("--json", "emit a JSON command summary").action(async (options) => {
+    await safeTrackWizardTelemetry("work_graph_preview_started", {
+      command: "work-graph preview",
+      from: options.from ?? "manual"
+    });
+    await runWorkGraphCommand(options);
+  });
+  workGraph.command("profile").description("Build a local OrgX Profile with Work Graph Trails, Mirror, tensions, and launch recommendations.").option("--input <path>", "source transcript or summary file; stdin is used when piped").option("--from <sources>", "auto-import recent local AI sessions: codex, claude, or all").option("--session-limit <count>", "max recent sessions to import per selected source", "5").option("--session-days <days>", "lookback window for local AI-session imports", "30").option("--codex-sessions-dir <path>", "override Codex sessions directory for import").option("--claude-projects-dir <path>", "override Claude projects directory for import").option("--source-label <label>", "label for the imported manual source").option("--workspace-id <id>", "workspace id override; defaults to the current OrgX workspace when authenticated").option("--workspace-name <name>", "workspace name override for local-only profiles").option("--output-dir <path>", "directory for generated Work Graph JSON and Markdown", ".orgx/work-graph").option("--json", "emit a JSON command summary").action(async (options) => {
+    await safeTrackWizardTelemetry("work_graph_profile_started", {
+      command: "work-graph profile",
+      from: options.from ?? "manual"
+    });
+    await runWorkGraphCommand(options);
+  });
+  const sessions = program.command("sessions").description("Inspect and reconcile local AI sessions into OrgX-ready Work Graph reports.");
+  sessions.command("reconcile").description("Backfill recent Codex and Claude sessions into a redacted Work Graph report.").option("--from <sources>", "auto-import recent local AI sessions: codex, claude, or all", "all").option("--session-limit <count>", "max recent sessions to import per selected source", "5").option("--session-days <days>", "lookback window for local AI-session imports", "7").option("--codex-sessions-dir <path>", "override Codex sessions directory for import").option("--claude-projects-dir <path>", "override Claude projects directory for import").option("--workspace-id <id>", "workspace id override; defaults to the current OrgX workspace when authenticated").option("--workspace-name <name>", "workspace name override for local-only reconciliation").option("--output-dir <path>", "directory for generated Work Graph JSON and Markdown", ".orgx/work-graph").option("--json", "emit a JSON command summary").action(async (options) => {
+    await safeTrackWizardTelemetry("sessions_reconcile_started", {
+      command: "sessions reconcile",
+      from: options.from ?? "all"
+    });
+    await runWorkGraphCommand(options, { from: "all" });
+  });
+  const hooks = program.command("hooks").description("Inspect or install passive OrgX runtime hooks for local agent clients.");
+  hooks.command("doctor").description("Show Codex and Claude Code runtime hook wiring status.").option("--json", "emit a JSON command summary").action(async (options) => {
+    const report = inspectRuntimeHooks();
+    await safeTrackWizardTelemetry("hooks_doctor_ran", {
+      command: "hooks doctor",
+      codex_installed: report.installed.codex,
+      claude_code_installed: report.installed.claudeCode,
+      hook_script_installed: report.installed.hookScript
+    });
+    if (options.json) {
+      console.log(JSON.stringify(report, null, 2));
+      return;
+    }
+    printRuntimeHookInspection(report);
+  });
+  hooks.command("install").description("Install passive OrgX runtime hooks for Codex and/or Claude Code.").option("--targets <targets>", "comma-separated targets: codex, claude-code, or all", "all").option("--json", "emit a JSON command summary").action(async (options) => {
+    const targets = parseRuntimeHookTargets(options.targets);
+    const result = installRuntimeHooks(targets);
+    await safeTrackWizardTelemetry("hooks_install_ran", {
+      command: "hooks install",
+      targets: targets.join(","),
+      codex_changed: result.changed.codex,
+      claude_code_changed: result.changed.claudeCode
+    });
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    printRuntimeHookInspection(result);
+    if (result.backups.length > 0) {
+      console.log("");
+      console.log(pc3.dim("  backups"));
+      for (const backup of result.backups) {
+        console.log(`  ${ICON.skip}  ${pc3.dim(backup)}`);
+      }
+    }
+  });
   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();