@useorgx/wizard 0.1.27 → 0.1.29

package/dist/cli.js

@@ -6229,6 +6229,8 @@ 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|mcp|tool call|orgx_emit_activity|orgx_apply_changeset|complete_with_proof|scaffold_initiative|mcp__orgx__)\b/i;
+var INSTRUCTION_BOILERPLATE_PATTERN = /^(?:#{1,6}\s*)?(?:agents\.md|instructions?|codex guardrails|precedence|read before you write|use exactly what was specified|don'?t confuse technologies|repo \+ scope hygiene|initiative \/ mcp discipline|ui quality bar|verification standards|secrets \+ safety|patch\/editing rules|commit \/ pr \/ merge protocol|output style|mcp integration|agent domains|skills|conventions)\b/i;
+var IMPERATIVE_BOILERPLATE_PATTERN = /^[-*]\s+(?:if the user|when the user|never|always|do not|don'?t|default to|treat|produce|pick|verify|avoid|match|use exactly|keep system boundaries|quote bracketed|for orgx|when capture tooling|if no meaningful|do \*\*not\*\*)\b/i;
 function parseAiSessionSources(value) {
   if (!value?.trim()) return [];
   const requested = value.split(",").map((item) => item.trim().toLowerCase()).filter(Boolean);
@@ -6284,7 +6286,9 @@ function extractClaudeMessageText(record) {
   return text2;
 }
 function keepAuditRelevantLines(text2) {
-  return text2.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0 && AUDIT_RELEVANT_LINE_PATTERN.test(line));
+  return text2.split(/\r?\n/).map((line) => line.trim()).filter(
+    (line) => line.length > 0 && AUDIT_RELEVANT_LINE_PATTERN.test(line) && !INSTRUCTION_BOILERPLATE_PATTERN.test(line) && !IMPERATIVE_BOILERPLATE_PATTERN.test(line)
+  );
 }
 function collectJsonlFiles(root, source) {
   if (!existsSync5(root)) return [];
@@ -6908,6 +6912,10 @@ function shortHash(value, length = 16) {
 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";
@@ -7169,6 +7177,491 @@ function buildKickoffs(findings, missed, score) {
   }
   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) {
@@ -7195,6 +7688,24 @@ function buildWorkGraphFingerprint(input) {
       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,
@@ -7211,6 +7722,8 @@ function buildWorkGraphFingerprint(input) {
     ),
     finding_type_counts: countFindingsByType(input.findings),
     pattern_hashes: patternHashes,
+    trail_shape_hashes: trailShapeHashes,
+    recurring_pattern_hashes: recurringPatternHashes,
     kickoff_hashes: kickoffHashes,
     raw_transcripts_included: false
   };
@@ -7241,13 +7754,30 @@ function buildSessionReconciliationReport(input) {
   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 = {
@@ -7277,6 +7807,11 @@ function buildSessionReconciliationReport(input) {
     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",
@@ -7312,6 +7847,38 @@ function renderWorkGraphMarkdown(report) {
   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)) {
@@ -7334,6 +7901,12 @@ function renderWorkGraphMarkdown(report) {
     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}`);
@@ -7991,7 +8564,11 @@ async function runWorkGraphCommand(options, defaults = {}) {
       finalState: report.final_state,
       opportunityScore: report.opportunity_score,
       missedOrchestration: report.missed_orchestration_opportunities.length,
-      kickoffCount: report.initiative_kickoffs.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;
   }
@@ -8003,6 +8580,12 @@ async function runWorkGraphCommand(options, defaults = {}) {
   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}`);
   }
@@ -8965,7 +9548,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.27" : void 0;
+  const pkgVersion = true ? "0.1.29" : void 0;
   program.version(pkgVersion ?? "unknown", "-V, --version");
   program.hook("preAction", () => {
     console.log(renderBanner(pkgVersion));
@@ -9672,6 +10255,13 @@ async function main() {
     });
     await runWorkGraphCommand(options);
   });
+  workGraph.command("profile").description("Build a local OrgX Profile with Work Graph Trails, Mirror, tensions, and launch recommendations.").option("--input <path>", "source transcript or summary file; stdin is used when piped").option("--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", {