@useorgx/wizard 0.1.26 → 0.1.27

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,769 @@ 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 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 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 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,
+    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 opportunityScore = scoreOpportunity(coverage, allFindings);
+  const initiativeKickoffs = buildKickoffs(allFindings, missed, opportunityScore);
+  const fingerprint = buildWorkGraphFingerprint({
+    connectedSources,
+    findings: allFindings,
+    kickoffs: initiativeKickoffs,
+    missingSources,
+    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,
+    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("## 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("## 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 +7755,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 +7953,60 @@ 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
+    }, 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"}`)}`);
+  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 +8965,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.27" : void 0;
   program.version(pkgVersion ?? "unknown", "-V, --version");
   program.hook("preAction", () => {
     console.log(renderBanner(pkgVersion));
@@ -8828,6 +9664,59 @@ 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);
+  });
+  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();