@skillkit/core 1.19.0 → 1.19.1

package/dist/index.js

@@ -8786,6 +8786,676 @@ var SessionExplainer = class {
   }
 };
 
+// src/session/timeline.ts
+function formatDuration2(ms) {
+  const seconds = Math.floor(ms / 1e3);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  if (hours > 0) return `${hours}h ${minutes % 60}m`;
+  if (minutes > 0) return `${minutes}m`;
+  return `${seconds}s`;
+}
+function formatTime(iso) {
+  const d = new Date(iso);
+  if (isNaN(d.getTime())) return iso;
+  return d.toLocaleTimeString("en-US", { hour: "numeric", minute: "2-digit", hour12: true });
+}
+var SessionTimeline = class {
+  projectPath;
+  sessionManager;
+  activityLog;
+  snapshotManager;
+  constructor(projectPath) {
+    this.projectPath = projectPath;
+    this.sessionManager = new SessionManager(projectPath);
+    this.activityLog = new ActivityLog(projectPath);
+    this.snapshotManager = new SnapshotManager(projectPath);
+  }
+  build(options) {
+    const events = [];
+    const state = this.sessionManager.get();
+    const limit = options?.limit ?? 50;
+    const includeGit = options?.includeGit !== false;
+    const sinceDate = options?.since ? new Date(options.since) : void 0;
+    if (sinceDate && isNaN(sinceDate.getTime())) {
+      return { projectPath: this.projectPath, sessionDate: (/* @__PURE__ */ new Date()).toISOString().split("T")[0], events: [], totalCount: 0 };
+    }
+    if (state?.currentExecution) {
+      const exec2 = state.currentExecution;
+      events.push({
+        timestamp: exec2.startedAt,
+        type: "skill_start",
+        source: exec2.skillName,
+        summary: `${exec2.skillName} started`,
+        details: { status: exec2.status, totalSteps: exec2.totalSteps }
+      });
+      const activeStatuses = /* @__PURE__ */ new Set(["in_progress", "completed", "failed"]);
+      for (const task of exec2.tasks) {
+        if (task.startedAt && activeStatuses.has(task.status)) {
+          events.push({
+            timestamp: task.completedAt ?? task.startedAt,
+            type: "task_progress",
+            source: exec2.skillName,
+            summary: `${task.name} (${task.status})`,
+            details: { taskId: task.id, error: task.error }
+          });
+        }
+      }
+    }
+    for (const hist of state?.history ?? []) {
+      events.push({
+        timestamp: hist.completedAt,
+        type: "skill_complete",
+        source: hist.skillName,
+        summary: `${hist.skillName} ${hist.status} (${formatDuration2(hist.durationMs)})`,
+        details: {
+          durationMs: hist.durationMs,
+          commits: hist.commits,
+          filesModified: hist.filesModified
+        }
+      });
+    }
+    if (includeGit) {
+      try {
+        const commits = getGitCommits(this.projectPath, {
+          commits: 50,
+          since: options?.since
+        });
+        for (const commit of commits) {
+          const activity = this.activityLog.getByCommit(commit.shortHash);
+          events.push({
+            timestamp: commit.date,
+            type: "git_commit",
+            source: activity?.activeSkills?.join(", ") ?? "git",
+            summary: `${commit.shortHash} \u2014 ${commit.message} (${commit.files.length} files)`,
+            details: {
+              sha: commit.hash,
+              author: commit.author,
+              skills: activity?.activeSkills
+            }
+          });
+        }
+      } catch {
+      }
+    }
+    try {
+      const observations = ObservationStore.readAll(this.projectPath);
+      for (const obs of observations) {
+        events.push({
+          timestamp: obs.timestamp,
+          type: "observation",
+          source: String(obs.agent),
+          summary: `${obs.type}: ${obs.content?.action ?? "unknown"}`,
+          details: { observationId: obs.id, ...obs.content }
+        });
+      }
+    } catch {
+    }
+    for (const decision of state?.decisions ?? []) {
+      events.push({
+        timestamp: decision.madeAt,
+        type: "decision",
+        source: decision.skillName ?? "user",
+        summary: `${decision.key} \u2192 ${decision.value}`
+      });
+    }
+    try {
+      const snapshots = this.snapshotManager.list();
+      for (const snap of snapshots) {
+        events.push({
+          timestamp: snap.createdAt,
+          type: "snapshot",
+          source: "snapshot",
+          summary: `snapshot: ${snap.name}${snap.description ? ` \u2014 ${snap.description}` : ""}`,
+          details: { skillCount: snap.skillCount }
+        });
+      }
+    } catch {
+    }
+    let filtered = events;
+    if (sinceDate) {
+      filtered = filtered.filter((e) => new Date(e.timestamp) >= sinceDate);
+    }
+    if (options?.types && options.types.length > 0) {
+      const typeSet = new Set(options.types);
+      filtered = filtered.filter((e) => typeSet.has(e.type));
+    }
+    if (options?.skillFilter) {
+      const skill = options.skillFilter;
+      filtered = filtered.filter(
+        (e) => e.source.includes(skill) || e.details?.skills?.includes(skill)
+      );
+    }
+    filtered.sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+    const totalCount = filtered.length;
+    const limited = filtered.slice(-limit);
+    return {
+      projectPath: this.projectPath,
+      sessionDate: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
+      events: limited,
+      totalCount
+    };
+  }
+  formatText(data) {
+    const lines = [];
+    lines.push("  Session Timeline\n");
+    if (data.events.length === 0) {
+      lines.push("  No events found.\n");
+      return lines.join("\n");
+    }
+    const icons = {
+      skill_start: ">",
+      skill_complete: "\u2713",
+      task_progress: "\u2022",
+      git_commit: "*",
+      observation: "!",
+      decision: "?",
+      snapshot: "\u25C9"
+    };
+    let lastTimeBlock = "";
+    for (const event of data.events) {
+      const time = formatTime(event.timestamp);
+      if (time !== lastTimeBlock) {
+        if (lastTimeBlock) lines.push("");
+        lines.push(`  ${time}`);
+        lastTimeBlock = time;
+      }
+      const icon = icons[event.type] ?? "\u2022";
+      lines.push(`    ${icon} ${event.summary}`);
+    }
+    lines.push("");
+    if (data.totalCount > data.events.length) {
+      lines.push(`  Showing ${data.events.length} of ${data.totalCount} events`);
+    } else {
+      lines.push(`  ${data.totalCount} ${data.totalCount === 1 ? "event" : "events"} total`);
+    }
+    return lines.join("\n");
+  }
+  formatJson(data) {
+    return JSON.stringify(data, null, 2);
+  }
+};
+
+// src/session/handoff.ts
+function formatDuration3(ms) {
+  const seconds = Math.floor(ms / 1e3);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  if (hours > 0) return `${hours}h ${minutes % 60}m`;
+  if (minutes > 0) return `${minutes}m`;
+  return `${seconds}s`;
+}
+var SessionHandoff = class {
+  projectPath;
+  sessionManager;
+  activityLog;
+  constructor(projectPath) {
+    this.projectPath = projectPath;
+    this.sessionManager = new SessionManager(projectPath);
+    this.activityLog = new ActivityLog(projectPath);
+  }
+  generate(options) {
+    const state = this.sessionManager.get();
+    const includeGit = options?.includeGit !== false;
+    const includeObservations = options?.includeObservations !== false;
+    const maxObservations = options?.maxObservations ?? 20;
+    let agent = "unknown";
+    try {
+      const configAgent = loadConfig().agent;
+      if (configAgent && configAgent !== "universal") {
+        agent = configAgent;
+      }
+    } catch {
+    }
+    if (agent === "unknown" && state?.currentExecution?.skillSource) {
+      agent = state.currentExecution.skillSource;
+    }
+    const accomplished = this.buildAccomplished(state?.currentExecution?.tasks, state?.history ?? [], includeGit);
+    const pending = this.buildPending(state?.currentExecution?.tasks);
+    const keyFiles = this.buildKeyFiles(state?.currentExecution?.tasks, state?.history ?? []);
+    const observations = includeObservations ? this.buildObservations(maxObservations) : { errors: [], solutions: [], patterns: [] };
+    const recommendations = this.buildRecommendations(pending, observations, includeGit);
+    return {
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      fromAgent: agent,
+      projectPath: this.projectPath,
+      accomplished,
+      pending,
+      keyFiles,
+      observations,
+      recommendations
+    };
+  }
+  buildAccomplished(tasks, history, includeGit) {
+    const section = { tasks: [], commits: [] };
+    for (const task of tasks ?? []) {
+      if (task.status === "completed") {
+        let duration;
+        if (task.startedAt && task.completedAt) {
+          duration = formatDuration3(
+            new Date(task.completedAt).getTime() - new Date(task.startedAt).getTime()
+          );
+        }
+        section.tasks.push({
+          name: task.name,
+          duration,
+          commitSha: task.commitSha
+        });
+      }
+    }
+    for (const hist of history) {
+      if (hist.status === "completed") {
+        section.tasks.push({
+          name: hist.skillName,
+          duration: Number.isFinite(hist.durationMs) ? formatDuration3(hist.durationMs) : void 0,
+          commitSha: hist.commits?.[0]
+        });
+      }
+    }
+    if (includeGit) {
+      try {
+        const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+        const commits = getGitCommits(this.projectPath, { commits: 50 });
+        for (const commit of commits) {
+          if (commit.date.startsWith(today)) {
+            section.commits.push({
+              sha: commit.shortHash,
+              message: commit.message,
+              filesCount: commit.files.length
+            });
+          }
+        }
+      } catch {
+      }
+    }
+    return section;
+  }
+  buildPending(tasks) {
+    const section = { tasks: [], commits: [] };
+    const pendingStatuses = /* @__PURE__ */ new Set(["pending", "in_progress", "paused"]);
+    for (const task of tasks ?? []) {
+      if (pendingStatuses.has(task.status)) {
+        section.tasks.push({ name: task.name });
+      }
+    }
+    return section;
+  }
+  buildKeyFiles(tasks, history) {
+    const fileMap = /* @__PURE__ */ new Map();
+    for (const task of tasks ?? []) {
+      for (const f of task.filesModified ?? []) {
+        fileMap.set(f, task.status === "completed" ? "modified" : "in-progress");
+      }
+    }
+    for (const hist of history) {
+      for (const f of hist.filesModified ?? []) {
+        if (!fileMap.has(f)) {
+          fileMap.set(f, "modified");
+        }
+      }
+    }
+    return Array.from(fileMap.entries()).map(([path4, changeType]) => ({ path: path4, changeType })).sort((a, b) => a.path.localeCompare(b.path));
+  }
+  buildObservations(max) {
+    const result = {
+      errors: [],
+      solutions: [],
+      patterns: []
+    };
+    try {
+      const observations = ObservationStore.readAll(this.projectPath);
+      const sorted = [...observations].sort((a, b) => b.relevance - a.relevance);
+      let count = 0;
+      for (const obs of sorted) {
+        if (count >= max) break;
+        if (obs.type === "error" && obs.content.error) {
+          result.errors.push({ action: obs.content.action, error: obs.content.error });
+          count++;
+        } else if (obs.type === "solution" && obs.content.solution) {
+          result.solutions.push({ action: obs.content.action, solution: obs.content.solution });
+          count++;
+        } else if (obs.type === "pattern" && obs.content.context) {
+          result.patterns.push({ action: obs.content.action, context: obs.content.context });
+          count++;
+        }
+      }
+    } catch {
+    }
+    return result;
+  }
+  buildRecommendations(pending, observations, includeGit) {
+    const recs = [];
+    if (pending.tasks.length > 0) {
+      recs.push(`Complete pending tasks: ${pending.tasks.map((t) => t.name).join(", ")}`);
+    }
+    if (observations.errors.length > 0) {
+      const unresolved = observations.errors.filter(
+        (e) => !observations.solutions.some((s) => s.action === e.action)
+      );
+      if (unresolved.length > 0) {
+        recs.push(`Resolve ${unresolved.length} unresolved error(s)`);
+      }
+    }
+    if (includeGit) {
+      try {
+        const activities = this.activityLog.getRecent(50);
+        const fileCounts = /* @__PURE__ */ new Map();
+        for (const activity of activities) {
+          for (const f of activity.filesChanged) {
+            fileCounts.set(f, (fileCounts.get(f) ?? 0) + 1);
+          }
+        }
+        const highChurn = Array.from(fileCounts.entries()).filter(([, count]) => count >= 3).sort((a, b) => b[1] - a[1]).slice(0, 3);
+        for (const [file, count] of highChurn) {
+          recs.push(`Review high-churn file: ${file} (${count} changes)`);
+        }
+      } catch {
+      }
+    }
+    return recs;
+  }
+  toMarkdown(doc) {
+    const lines = [];
+    lines.push(`# Session Handoff`);
+    lines.push(`Agent: ${doc.fromAgent} | ${doc.generatedAt.split("T")[0]}
+`);
+    lines.push(`## Accomplished`);
+    if (doc.accomplished.tasks.length === 0 && doc.accomplished.commits.length === 0) {
+      lines.push("No completed tasks.\n");
+    } else {
+      for (const task of doc.accomplished.tasks) {
+        const dur = task.duration ? ` (${task.duration})` : "";
+        const sha = task.commitSha ? ` [${task.commitSha.slice(0, 7)}]` : "";
+        lines.push(`- ${task.name}${dur}${sha}`);
+      }
+      for (const commit of doc.accomplished.commits) {
+        lines.push(`- ${commit.sha} \u2014 ${commit.message} (${commit.filesCount} files)`);
+      }
+      lines.push("");
+    }
+    lines.push(`## Pending`);
+    if (doc.pending.tasks.length === 0) {
+      lines.push("No pending tasks.\n");
+    } else {
+      for (const task of doc.pending.tasks) {
+        lines.push(`- ${task.name}`);
+      }
+      lines.push("");
+    }
+    if (doc.keyFiles.length > 0) {
+      lines.push(`## Key Files`);
+      for (const f of doc.keyFiles) {
+        lines.push(`- \`${f.path}\` (${f.changeType})`);
+      }
+      lines.push("");
+    }
+    const hasObs = doc.observations.errors.length > 0 || doc.observations.solutions.length > 0 || doc.observations.patterns.length > 0;
+    if (hasObs) {
+      lines.push(`## Observations`);
+      for (const e of doc.observations.errors) {
+        lines.push(`- Error: ${e.error} (${e.action})`);
+      }
+      for (const s of doc.observations.solutions) {
+        lines.push(`- Solution: ${s.solution} (${s.action})`);
+      }
+      for (const p of doc.observations.patterns) {
+        lines.push(`- Pattern: ${p.action} \u2014 ${p.context}`);
+      }
+      lines.push("");
+    }
+    if (doc.recommendations.length > 0) {
+      lines.push(`## Recommendations`);
+      doc.recommendations.forEach((r, i) => {
+        lines.push(`${i + 1}. ${r}`);
+      });
+      lines.push("");
+    }
+    return lines.join("\n");
+  }
+  toJson(doc) {
+    return JSON.stringify(doc, null, 2);
+  }
+};
+
+// src/session/lineage.ts
+function formatDurationMs(ms) {
+  const seconds = Math.floor(ms / 1e3);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  if (hours > 0) return `${hours}h ${minutes % 60}m`;
+  if (minutes > 0) return `${minutes}m`;
+  return `${seconds}s`;
+}
+var SkillLineage = class {
+  projectPath;
+  sessionManager;
+  activityLog;
+  constructor(projectPath) {
+    this.projectPath = projectPath;
+    this.sessionManager = new SessionManager(projectPath);
+    this.activityLog = new ActivityLog(projectPath);
+  }
+  build(options) {
+    const state = this.sessionManager.get();
+    const sinceDate = options?.since ? new Date(options.since) : void 0;
+    const skillMap = /* @__PURE__ */ new Map();
+    const fileSkillMap = /* @__PURE__ */ new Map();
+    const fileCommitCount = /* @__PURE__ */ new Map();
+    const fileLastModified = /* @__PURE__ */ new Map();
+    for (const hist of state?.history ?? []) {
+      if (sinceDate && new Date(hist.completedAt) < sinceDate) continue;
+      const entry = skillMap.get(hist.skillName) ?? {
+        skillName: hist.skillName,
+        executions: 0,
+        totalDurationMs: 0,
+        commits: [],
+        filesModified: [],
+        observationIds: [],
+        firstSeen: hist.completedAt,
+        lastSeen: hist.completedAt
+      };
+      entry.executions++;
+      entry.totalDurationMs += hist.durationMs;
+      entry.commits.push(...hist.commits ?? []);
+      entry.filesModified.push(...hist.filesModified ?? []);
+      if (new Date(hist.completedAt) < new Date(entry.firstSeen)) {
+        entry.firstSeen = hist.completedAt;
+      }
+      if (new Date(hist.completedAt) > new Date(entry.lastSeen)) {
+        entry.lastSeen = hist.completedAt;
+      }
+      skillMap.set(hist.skillName, entry);
+      for (const f of hist.filesModified ?? []) {
+        const skills2 = fileSkillMap.get(f) ?? /* @__PURE__ */ new Set();
+        skills2.add(hist.skillName);
+        fileSkillMap.set(f, skills2);
+        fileCommitCount.set(f, (fileCommitCount.get(f) ?? 0) + (hist.commits?.length ?? 0));
+        const existing = fileLastModified.get(f);
+        if (!existing || new Date(hist.completedAt) > new Date(existing)) {
+          fileLastModified.set(f, hist.completedAt);
+        }
+      }
+    }
+    if (state?.currentExecution) {
+      const exec2 = state.currentExecution;
+      const startTime = new Date(exec2.startedAt);
+      if (!sinceDate || startTime >= sinceDate) {
+        const entry = skillMap.get(exec2.skillName) ?? {
+          skillName: exec2.skillName,
+          executions: 0,
+          totalDurationMs: 0,
+          commits: [],
+          filesModified: [],
+          observationIds: [],
+          firstSeen: exec2.startedAt,
+          lastSeen: exec2.startedAt
+        };
+        entry.executions++;
+        entry.totalDurationMs += Date.now() - startTime.getTime();
+        for (const task of exec2.tasks) {
+          if (task.commitSha) entry.commits.push(task.commitSha);
+          entry.filesModified.push(...task.filesModified ?? []);
+          for (const f of task.filesModified ?? []) {
+            const skills2 = fileSkillMap.get(f) ?? /* @__PURE__ */ new Set();
+            skills2.add(exec2.skillName);
+            fileSkillMap.set(f, skills2);
+            if (task.commitSha) {
+              fileCommitCount.set(f, (fileCommitCount.get(f) ?? 0) + 1);
+            }
+            const existing = fileLastModified.get(f);
+            if (!existing || new Date(exec2.startedAt) > new Date(existing)) {
+              fileLastModified.set(f, exec2.startedAt);
+            }
+          }
+        }
+        if (new Date(exec2.startedAt) < new Date(entry.firstSeen)) {
+          entry.firstSeen = exec2.startedAt;
+        }
+        entry.lastSeen = (/* @__PURE__ */ new Date()).toISOString();
+        skillMap.set(exec2.skillName, entry);
+      }
+    }
+    try {
+      const activities = this.activityLog.getRecent(500);
+      for (const activity of activities) {
+        if (sinceDate && new Date(activity.committedAt) < sinceDate) continue;
+        const countedFiles = /* @__PURE__ */ new Set();
+        for (const skill of activity.activeSkills) {
+          const entry = skillMap.get(skill);
+          if (entry && !entry.commits.includes(activity.commitSha)) {
+            entry.commits.push(activity.commitSha);
+          }
+          for (const f of activity.filesChanged) {
+            const skills2 = fileSkillMap.get(f) ?? /* @__PURE__ */ new Set();
+            skills2.add(skill);
+            fileSkillMap.set(f, skills2);
+            if (!countedFiles.has(f)) {
+              fileCommitCount.set(f, (fileCommitCount.get(f) ?? 0) + 1);
+              countedFiles.add(f);
+            }
+            const existing = fileLastModified.get(f);
+            if (!existing || new Date(activity.committedAt) > new Date(existing)) {
+              fileLastModified.set(f, activity.committedAt);
+            }
+          }
+        }
+      }
+    } catch {
+    }
+    const errorProneFiles = [];
+    try {
+      const observations = ObservationStore.readAll(this.projectPath);
+      for (const obs of observations) {
+        if (sinceDate && new Date(obs.timestamp) < sinceDate) continue;
+        for (const [, entry] of skillMap) {
+          const execStart = new Date(entry.firstSeen).getTime();
+          const execEnd = new Date(entry.lastSeen).getTime();
+          const obsTime = new Date(obs.timestamp).getTime();
+          if (obsTime >= execStart && obsTime <= execEnd) {
+            if (!entry.observationIds.includes(obs.id)) {
+              entry.observationIds.push(obs.id);
+            }
+          }
+        }
+        if (obs.type === "error" && Array.isArray(obs.content?.files)) {
+          errorProneFiles.push(...obs.content.files);
+        }
+      }
+    } catch {
+    }
+    for (const entry of skillMap.values()) {
+      entry.commits = [...new Set(entry.commits)];
+      entry.filesModified = [...new Set(entry.filesModified)];
+    }
+    let skills = Array.from(skillMap.values());
+    let files = Array.from(fileSkillMap.entries()).map(([path4, skillSet]) => ({
+      path: path4,
+      skills: Array.from(skillSet),
+      commitCount: fileCommitCount.get(path4) ?? 0,
+      lastModified: fileLastModified.get(path4) ?? ""
+    }));
+    if (options?.skill) {
+      skills = skills.filter((s) => s.skillName === options.skill);
+      const skillFiles = new Set(skills.flatMap((s) => s.filesModified));
+      files = files.filter((f) => skillFiles.has(f.path));
+    }
+    if (options?.file) {
+      files = files.filter((f) => f.path === options.file || f.path.includes(options.file));
+      const fileSkills = new Set(files.flatMap((f) => f.skills));
+      skills = skills.filter((s) => fileSkills.has(s.skillName));
+    }
+    skills.sort((a, b) => b.filesModified.length - a.filesModified.length);
+    files.sort((a, b) => b.skills.length - a.skills.length || b.commitCount - a.commitCount);
+    if (options?.limit) {
+      skills = skills.slice(0, options.limit);
+      files = files.slice(0, options.limit);
+    }
+    const uniqueErrorFiles = [...new Set(errorProneFiles)];
+    const allCommits = new Set(skills.flatMap((s) => s.commits));
+    const allFiles = new Set(skills.flatMap((s) => s.filesModified));
+    const mostImpactful = skills.length > 0 ? skills[0].skillName : null;
+    const mostChanged = files.length > 0 ? files[0].path : null;
+    return {
+      projectPath: this.projectPath,
+      skills,
+      files,
+      stats: {
+        totalSkillExecutions: skills.reduce((sum, s) => sum + s.executions, 0),
+        totalCommits: allCommits.size,
+        totalFilesChanged: allFiles.size,
+        mostImpactfulSkill: mostImpactful,
+        mostChangedFile: mostChanged,
+        errorProneFiles: uniqueErrorFiles.slice(0, 5)
+      }
+    };
+  }
+  getSkillLineage(skillName) {
+    const data = this.build({ skill: skillName });
+    return data.skills.find((s) => s.skillName === skillName);
+  }
+  getFileLineage(filePath) {
+    const data = this.build({ file: filePath });
+    return data.files.find((f) => f.path === filePath || f.path.includes(filePath));
+  }
+  formatText(data) {
+    const lines = [];
+    lines.push("  Skill Lineage\n");
+    if (data.skills.length === 0) {
+      lines.push("  No skill executions found.\n");
+      return lines.join("\n");
+    }
+    lines.push("  Skills");
+    for (const skill of data.skills) {
+      const duration = formatDurationMs(skill.totalDurationMs);
+      lines.push(
+        `    ${skill.skillName.padEnd(24)} ${skill.executions} runs   ${skill.commits.length} commits   ${skill.filesModified.length} files   ${duration} total`
+      );
+    }
+    lines.push("");
+    const hotspots = data.files.filter((f) => f.skills.length >= 2);
+    if (hotspots.length > 0) {
+      lines.push("  File Hotspots (touched by 2+ skills)");
+      for (const f of hotspots.slice(0, 10)) {
+        lines.push(`    ${f.path.padEnd(40)} ${f.skills.join(", ")}`);
+      }
+      lines.push("");
+    }
+    lines.push("  Stats");
+    lines.push(`    Total executions: ${data.stats.totalSkillExecutions} | Commits: ${data.stats.totalCommits}`);
+    if (data.stats.mostImpactfulSkill) {
+      const skill = data.skills.find((s) => s.skillName === data.stats.mostImpactfulSkill);
+      lines.push(`    Most impactful: ${data.stats.mostImpactfulSkill} (${skill?.filesModified.length ?? 0} files)`);
+    }
+    if (data.stats.errorProneFiles.length > 0) {
+      lines.push(`    Error-prone: ${data.stats.errorProneFiles.join(", ")}`);
+    }
+    return lines.join("\n");
+  }
+  formatJson(data) {
+    return JSON.stringify(data, null, 2);
+  }
+};
+
 // src/workflow/types.ts
 var WORKFLOWS_DIR = "workflows";
 var WORKFLOW_EXTENSION = ".yaml";
@@ -33843,7 +34513,7 @@ var SkillScanner = class {
 
 // src/scanner/reporter.ts
 import { basename as basename21 } from "path";
-var SCANNER_VERSION = true ? "1.19.0" : "0.0.0";
+var SCANNER_VERSION = true ? "1.19.1" : "0.0.0";
 var SEVERITY_COLORS = {
   ["critical" /* CRITICAL */]: "\x1B[91m",
   ["high" /* HIGH */]: "\x1B[31m",
@@ -35014,8 +35684,10 @@ export {
   SecretsAnalyzer,
   SessionEndHook,
   SessionExplainer,
+  SessionHandoff,
   SessionManager,
   SessionStartHook,
+  SessionTimeline,
   Severity,
   Skill,
   SkillAnalyzer,
@@ -35026,6 +35698,7 @@ export {
   SkillFrontmatter,
   SkillGenerator,
   SkillInjector,
+  SkillLineage,
   SkillLocation,
   SkillMdTranslator,
   SkillMerger,