@skillkit/core 1.17.0 → 1.19.0

package/dist/index.js

@@ -7955,6 +7955,837 @@ function getMostRecentSession() {
   return loadSessionFile(summaries[0].date);
 }
 
+// src/session/activity-log.ts
+import { existsSync as existsSync18, mkdirSync as mkdirSync9, readFileSync as readFileSync10, writeFileSync as writeFileSync9 } from "fs";
+import { join as join17 } from "path";
+import { parse as parse2, stringify as stringify2 } from "yaml";
+var ACTIVITY_FILE = "activity.yaml";
+var ActivityLog = class {
+  filePath;
+  projectPath;
+  data = null;
+  constructor(projectPath) {
+    this.projectPath = projectPath;
+    this.filePath = join17(projectPath, ".skillkit", ACTIVITY_FILE);
+  }
+  createEmpty() {
+    return { version: 1, activities: [] };
+  }
+  load() {
+    if (this.data) return this.data;
+    if (!existsSync18(this.filePath)) {
+      this.data = this.createEmpty();
+      return this.data;
+    }
+    try {
+      const content = readFileSync10(this.filePath, "utf-8");
+      const parsed = parse2(content);
+      if (parsed && Array.isArray(parsed.activities)) {
+        this.data = parsed;
+      } else {
+        this.data = this.createEmpty();
+      }
+    } catch {
+      this.data = this.createEmpty();
+    }
+    return this.data;
+  }
+  save() {
+    const dir = join17(this.projectPath, ".skillkit");
+    if (!existsSync18(dir)) {
+      mkdirSync9(dir, { recursive: true });
+    }
+    writeFileSync9(this.filePath, stringify2(this.data));
+  }
+  record(entry) {
+    const data = this.load();
+    data.activities.unshift({
+      commitSha: entry.commitSha,
+      committedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      activeSkills: entry.activeSkills,
+      filesChanged: entry.filesChanged,
+      message: entry.message
+    });
+    if (data.activities.length > 500) {
+      data.activities = data.activities.slice(0, 500);
+    }
+    this.save();
+  }
+  getByCommit(sha) {
+    if (sha.length < 4) return void 0;
+    const data = this.load();
+    return data.activities.find(
+      (a) => a.commitSha === sha || a.commitSha.startsWith(sha)
+    );
+  }
+  getBySkill(skillName) {
+    const data = this.load();
+    return data.activities.filter((a) => a.activeSkills.includes(skillName));
+  }
+  getRecent(limit = 20) {
+    const data = this.load();
+    return data.activities.slice(0, limit);
+  }
+  getMostUsedSkills() {
+    const data = this.load();
+    const counts = /* @__PURE__ */ new Map();
+    for (const activity of data.activities) {
+      for (const skill of activity.activeSkills) {
+        counts.set(skill, (counts.get(skill) ?? 0) + 1);
+      }
+    }
+    return Array.from(counts.entries()).map(([skill, count]) => ({ skill, count })).sort((a, b) => b.count - a.count);
+  }
+};
+
+// src/session/snapshot-manager.ts
+import {
+  existsSync as existsSync19,
+  mkdirSync as mkdirSync10,
+  readFileSync as readFileSync11,
+  writeFileSync as writeFileSync10,
+  readdirSync as readdirSync5,
+  unlinkSync as unlinkSync2
+} from "fs";
+import { join as join18 } from "path";
+import { parse as parse3, stringify as stringify3 } from "yaml";
+var SAFE_NAME_RE = /^[a-zA-Z0-9_-]+$/;
+var SnapshotManager = class {
+  snapshotsDir;
+  constructor(projectPath) {
+    this.snapshotsDir = join18(projectPath, ".skillkit", "snapshots");
+  }
+  ensureDir() {
+    if (!existsSync19(this.snapshotsDir)) {
+      mkdirSync10(this.snapshotsDir, { recursive: true });
+    }
+  }
+  sanitizeName(name) {
+    if (!name || !SAFE_NAME_RE.test(name)) {
+      throw new Error(`Invalid snapshot name: "${name}". Use only letters, numbers, hyphens, and underscores.`);
+    }
+    return name;
+  }
+  getPath(name) {
+    const safe = this.sanitizeName(name);
+    return join18(this.snapshotsDir, `${safe}.yaml`);
+  }
+  save(name, sessionState, observations, description) {
+    this.ensureDir();
+    const snapshot = {
+      version: 1,
+      name,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      description,
+      sessionState,
+      observations
+    };
+    writeFileSync10(this.getPath(name), stringify3(snapshot));
+  }
+  restore(name) {
+    const filepath = this.getPath(name);
+    if (!existsSync19(filepath)) {
+      throw new Error(`Snapshot "${name}" not found`);
+    }
+    let snapshot;
+    try {
+      const content = readFileSync11(filepath, "utf-8");
+      snapshot = parse3(content);
+    } catch (err) {
+      throw new Error(`Failed to read snapshot "${name}": ${err instanceof Error ? err.message : "unknown error"}`);
+    }
+    if (!snapshot.sessionState || !snapshot.observations) {
+      throw new Error(`Snapshot "${name}" is corrupted or invalid`);
+    }
+    return {
+      sessionState: snapshot.sessionState,
+      observations: snapshot.observations
+    };
+  }
+  list() {
+    if (!existsSync19(this.snapshotsDir)) {
+      return [];
+    }
+    const files = readdirSync5(this.snapshotsDir).filter(
+      (f) => f.endsWith(".yaml")
+    );
+    return files.map((f) => {
+      try {
+        const content = readFileSync11(join18(this.snapshotsDir, f), "utf-8");
+        const snapshot = parse3(content);
+        if (!snapshot.createdAt) {
+          return null;
+        }
+        const skillCount = snapshot.sessionState?.history?.length ?? 0;
+        return {
+          name: snapshot.name ?? f.replace(/\.yaml$/, ""),
+          createdAt: snapshot.createdAt,
+          description: snapshot.description,
+          skillCount
+        };
+      } catch {
+        return null;
+      }
+    }).filter((s) => s !== null).sort((a, b) => {
+      const timeA = new Date(a.createdAt).getTime() || 0;
+      const timeB = new Date(b.createdAt).getTime() || 0;
+      return timeB - timeA;
+    });
+  }
+  get(name) {
+    const filepath = this.getPath(name);
+    if (!existsSync19(filepath)) {
+      return void 0;
+    }
+    try {
+      const content = readFileSync11(filepath, "utf-8");
+      return parse3(content);
+    } catch {
+      return void 0;
+    }
+  }
+  delete(name) {
+    const filepath = this.getPath(name);
+    if (!existsSync19(filepath)) {
+      return false;
+    }
+    unlinkSync2(filepath);
+    return true;
+  }
+  exists(name) {
+    return existsSync19(this.getPath(name));
+  }
+};
+
+// src/memory/observation-store.ts
+import { existsSync as existsSync20, mkdirSync as mkdirSync11, readFileSync as readFileSync12, writeFileSync as writeFileSync11 } from "fs";
+import { dirname as dirname4, join as join19 } from "path";
+import { parse as parseYaml6, stringify as stringifyYaml5 } from "yaml";
+import { randomUUID as randomUUID6 } from "crypto";
+var ObservationStore = class {
+  filePath;
+  projectPath;
+  data = null;
+  sessionId;
+  compressionThreshold;
+  autoCompress;
+  onThresholdReached;
+  compressionInProgress = false;
+  constructor(projectPath, sessionId, options = {}) {
+    this.projectPath = projectPath;
+    this.filePath = join19(projectPath, ".skillkit", "memory", "observations.yaml");
+    this.sessionId = sessionId || randomUUID6();
+    this.compressionThreshold = options.compressionThreshold ?? 50;
+    this.autoCompress = options.autoCompress ?? true;
+    this.onThresholdReached = options.onThresholdReached;
+  }
+  ensureDir() {
+    const dir = dirname4(this.filePath);
+    if (!existsSync20(dir)) {
+      mkdirSync11(dir, { recursive: true });
+    }
+  }
+  load() {
+    if (this.data) return this.data;
+    if (existsSync20(this.filePath)) {
+      try {
+        const content = readFileSync12(this.filePath, "utf-8");
+        this.data = parseYaml6(content);
+        if (this.data.sessionId !== this.sessionId) {
+          this.data.sessionId = this.sessionId;
+          this.data.observations = [];
+        }
+      } catch {
+        this.data = this.createEmpty();
+      }
+    } else {
+      this.data = this.createEmpty();
+    }
+    return this.data;
+  }
+  createEmpty() {
+    return {
+      version: 1,
+      sessionId: this.sessionId,
+      observations: []
+    };
+  }
+  save() {
+    this.ensureDir();
+    const content = stringifyYaml5(this.data, { lineWidth: 0 });
+    writeFileSync11(this.filePath, content, "utf-8");
+  }
+  add(type, content, agent, relevance = 50) {
+    const data = this.load();
+    const observation = {
+      id: randomUUID6(),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      sessionId: this.sessionId,
+      agent,
+      type,
+      content,
+      relevance
+    };
+    data.observations.push(observation);
+    this.save();
+    void this.checkAutoCompression().catch(() => {
+    });
+    return observation;
+  }
+  /**
+   * Check if auto-compression should trigger
+   */
+  async checkAutoCompression() {
+    if (!this.autoCompress || this.compressionInProgress) return;
+    if (!this.onThresholdReached) return;
+    const count = this.count();
+    if (count >= this.compressionThreshold) {
+      this.compressionInProgress = true;
+      try {
+        const observations = this.getAll();
+        await this.onThresholdReached(observations);
+      } finally {
+        this.compressionInProgress = false;
+      }
+    }
+  }
+  /**
+   * Set auto-compression callback
+   */
+  setAutoCompressCallback(callback) {
+    this.onThresholdReached = callback;
+  }
+  /**
+   * Enable/disable auto-compression
+   */
+  setAutoCompress(enabled) {
+    this.autoCompress = enabled;
+  }
+  /**
+   * Set compression threshold
+   */
+  setCompressionThreshold(threshold) {
+    if (threshold < 1 || !Number.isInteger(threshold)) {
+      throw new Error("Compression threshold must be a positive integer");
+    }
+    this.compressionThreshold = threshold;
+  }
+  /**
+   * Get compression threshold
+   */
+  getCompressionThreshold() {
+    return this.compressionThreshold;
+  }
+  /**
+   * Check if threshold is reached
+   */
+  isThresholdReached() {
+    return this.count() >= this.compressionThreshold;
+  }
+  /**
+   * Get project path
+   */
+  getProjectPath() {
+    return this.projectPath;
+  }
+  getAll() {
+    return this.load().observations;
+  }
+  static readAll(projectPath) {
+    const filePath = join19(projectPath, ".skillkit", "memory", "observations.yaml");
+    if (!existsSync20(filePath)) return [];
+    try {
+      const content = readFileSync12(filePath, "utf-8");
+      const data = parseYaml6(content);
+      return data?.observations ?? [];
+    } catch {
+      return [];
+    }
+  }
+  getByType(type) {
+    return this.load().observations.filter((o) => o.type === type);
+  }
+  getByRelevance(minRelevance) {
+    return this.load().observations.filter((o) => o.relevance >= minRelevance);
+  }
+  getRecent(count) {
+    const observations = this.load().observations;
+    return observations.slice(-count);
+  }
+  getUncompressed(compressedIds) {
+    const compressedSet = new Set(compressedIds);
+    return this.load().observations.filter((o) => !compressedSet.has(o.id));
+  }
+  count() {
+    return this.load().observations.length;
+  }
+  clear() {
+    this.data = this.createEmpty();
+    this.save();
+  }
+  getById(id) {
+    return this.load().observations.find((o) => o.id === id);
+  }
+  getByIds(ids) {
+    const idSet = new Set(ids);
+    return this.load().observations.filter((o) => idSet.has(o.id));
+  }
+  getSessionId() {
+    return this.sessionId;
+  }
+  setSessionId(sessionId) {
+    this.sessionId = sessionId;
+    if (this.data) {
+      this.data.sessionId = sessionId;
+    }
+  }
+  exists() {
+    return existsSync20(this.filePath);
+  }
+  delete(id) {
+    const data = this.load();
+    const index = data.observations.findIndex((o) => o.id === id);
+    if (index === -1) return false;
+    data.observations.splice(index, 1);
+    this.save();
+    return true;
+  }
+  deleteMany(ids) {
+    const idSet = new Set(ids);
+    const data = this.load();
+    const initialLength = data.observations.length;
+    data.observations = data.observations.filter((o) => !idSet.has(o.id));
+    if (data.observations.length !== initialLength) {
+      this.save();
+    }
+    return initialLength - data.observations.length;
+  }
+};
+
+// src/learning/git-analyzer.ts
+import { execSync as execSync5 } from "child_process";
+import { existsSync as existsSync21 } from "fs";
+import { join as join20 } from "path";
+function runGitCommand(command, cwd) {
+  try {
+    return execSync5(command, { cwd, encoding: "utf-8", maxBuffer: 10 * 1024 * 1024 });
+  } catch {
+    return "";
+  }
+}
+function isGitRepository(path4) {
+  return existsSync21(join20(path4, ".git"));
+}
+function getGitCommits(repoPath, options = {}) {
+  if (!isGitRepository(repoPath)) {
+    return [];
+  }
+  const limit = options.commits || 100;
+  const args = [
+    "log",
+    `--max-count=${limit}`,
+    "--format=%H|||%h|||%an|||%aI|||%s|||%b|||END_COMMIT",
+    "--name-status"
+  ];
+  if (options.since) {
+    args.push(`--since="${options.since}"`);
+  }
+  if (options.until) {
+    args.push(`--until="${options.until}"`);
+  }
+  if (options.branch) {
+    args.push(options.branch);
+  }
+  if (options.author) {
+    args.push(`--author="${options.author}"`);
+  }
+  const output = runGitCommand(`git ${args.join(" ")}`, repoPath);
+  if (!output) return [];
+  const commits = [];
+  const commitBlocks = output.split("END_COMMIT").filter((b) => b.trim());
+  for (const block of commitBlocks) {
+    const lines = block.trim().split("\n");
+    if (lines.length === 0) continue;
+    const headerLine = lines[0];
+    const parts = headerLine.split("|||");
+    if (parts.length < 5) continue;
+    const [hash, shortHash, author, date, message, body] = parts;
+    const files = [];
+    for (let i = 1; i < lines.length; i++) {
+      const line = lines[i].trim();
+      if (!line) continue;
+      const match = line.match(/^([AMDRT])\d*\t(.+?)(?:\t(.+))?$/);
+      if (match) {
+        const [, status, path4, oldPath] = match;
+        files.push({
+          path: path4,
+          status: parseFileStatus(status),
+          additions: 0,
+          deletions: 0,
+          oldPath: oldPath || void 0
+        });
+      }
+    }
+    commits.push({
+      hash,
+      shortHash,
+      author,
+      date,
+      message,
+      body: body || void 0,
+      files
+    });
+  }
+  return commits;
+}
+function parseFileStatus(status) {
+  switch (status) {
+    case "A":
+      return "added";
+    case "D":
+      return "deleted";
+    case "R":
+      return "renamed";
+    default:
+      return "modified";
+  }
+}
+function categorizeCommit(message, body) {
+  const text = `${message} ${body || ""}`.toLowerCase();
+  if (text.includes("fix") || text.includes("bug") || text.includes("error") || text.includes("issue")) {
+    return "error_fix";
+  }
+  if (text.includes("refactor") || text.includes("clean") || text.includes("simplify")) {
+    return "refactor";
+  }
+  if (text.includes("workaround") || text.includes("hack") || text.includes("temporary")) {
+    return "workaround";
+  }
+  if (text.includes("debug") || text.includes("log") || text.includes("trace")) {
+    return "debugging";
+  }
+  return null;
+}
+function shouldSkipCommit(commit, ignorePatterns) {
+  const message = commit.message.toLowerCase();
+  for (const pattern of ignorePatterns) {
+    if (message.includes(pattern.toLowerCase())) {
+      return true;
+    }
+  }
+  if (message.startsWith("merge ") || message.startsWith("wip")) {
+    return true;
+  }
+  if (commit.files.length === 0) {
+    return true;
+  }
+  return false;
+}
+function extractPatternFromCommit(commit) {
+  const category = categorizeCommit(commit.message, commit.body);
+  if (!category) return null;
+  const id = `git-${commit.shortHash}`;
+  const title = formatTitle(commit.message);
+  const problem = extractProblem(commit);
+  const solution = extractSolution(commit);
+  const context = extractContext(commit);
+  if (!problem || !solution) return null;
+  return {
+    id,
+    category,
+    title,
+    problem,
+    solution,
+    context,
+    extractedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    source: "git",
+    commitRange: { from: commit.hash, to: commit.hash },
+    approved: false,
+    confidence: calculateConfidence(commit, category)
+  };
+}
+function formatTitle(message) {
+  return message.charAt(0).toUpperCase() + message.slice(1);
+}
+function extractProblem(commit) {
+  const message = commit.message.toLowerCase();
+  if (message.includes("fix:") || message.includes("fix(")) {
+    const match = commit.message.match(/fix[:(]\s*([^)]+)/i);
+    if (match) {
+      return `Issue: ${match[1]}`;
+    }
+  }
+  if (commit.body) {
+    const problemMatch = commit.body.match(/problem:?\s*(.+)/i);
+    if (problemMatch) {
+      return problemMatch[1].trim();
+    }
+  }
+  return `${commit.message} (from commit ${commit.shortHash})`;
+}
+function extractSolution(commit) {
+  if (commit.body) {
+    const solutionMatch = commit.body.match(/solution:?\s*(.+)/i);
+    if (solutionMatch) {
+      return solutionMatch[1].trim();
+    }
+  }
+  const files = commit.files.map((f) => f.path).join(", ");
+  return `Modified: ${files}`;
+}
+function extractContext(commit) {
+  const files = commit.files;
+  const extensions = new Set(files.map((f) => f.path.split(".").pop() || ""));
+  const directories = new Set(files.map((f) => f.path.split("/")[0]));
+  const parts = [];
+  if (extensions.size > 0) {
+    parts.push(`Files: ${Array.from(extensions).filter((e) => e).join(", ")}`);
+  }
+  if (directories.size > 0 && directories.size <= 3) {
+    parts.push(`Areas: ${Array.from(directories).join(", ")}`);
+  }
+  return parts.join(". ") || "General codebase";
+}
+function calculateConfidence(commit, category) {
+  let confidence = 0.5;
+  if (commit.body && commit.body.length > 50) {
+    confidence += 0.1;
+  }
+  if (commit.message.match(/^(fix|feat|refactor|docs|test|chore)(\(.+\))?:/)) {
+    confidence += 0.1;
+  }
+  if (commit.files.length > 0 && commit.files.length < 10) {
+    confidence += 0.1;
+  }
+  if (category === "error_fix" || category === "workaround") {
+    confidence += 0.05;
+  }
+  return Math.min(0.9, confidence);
+}
+function analyzeGitHistory(repoPath, options = {}) {
+  const commits = getGitCommits(repoPath, options);
+  const ignorePatterns = ["merge", "wip", "typo"];
+  const patterns = [];
+  const summary = {
+    totalCommits: commits.length,
+    totalFilesChanged: 0,
+    errorFixes: 0,
+    refactors: 0,
+    features: 0,
+    documentation: 0,
+    tests: 0
+  };
+  const languages = /* @__PURE__ */ new Set();
+  const frameworks = /* @__PURE__ */ new Set();
+  for (const commit of commits) {
+    if (shouldSkipCommit(commit, ignorePatterns)) {
+      continue;
+    }
+    summary.totalFilesChanged += commit.files.length;
+    for (const file of commit.files) {
+      const ext = file.path.split(".").pop()?.toLowerCase();
+      if (ext) {
+        if (["ts", "tsx"].includes(ext)) languages.add("TypeScript");
+        else if (["js", "jsx"].includes(ext)) languages.add("JavaScript");
+        else if (ext === "py") languages.add("Python");
+        else if (ext === "go") languages.add("Go");
+        else if (ext === "rs") languages.add("Rust");
+        else if (ext === "java") languages.add("Java");
+      }
+      if (file.path.includes("next")) frameworks.add("Next.js");
+      if (file.path.includes("react")) frameworks.add("React");
+      if (file.path.includes("vue")) frameworks.add("Vue");
+    }
+    const category = categorizeCommit(commit.message, commit.body);
+    if (category === "error_fix") summary.errorFixes++;
+    else if (category === "refactor") summary.refactors++;
+    if (commit.message.toLowerCase().includes("feat")) summary.features++;
+    if (commit.message.toLowerCase().includes("doc")) summary.documentation++;
+    if (commit.message.toLowerCase().includes("test")) summary.tests++;
+    const pattern = extractPatternFromCommit(commit);
+    if (pattern) {
+      patterns.push(pattern);
+    }
+  }
+  const dates = commits.map((c) => c.date).sort();
+  return {
+    patterns,
+    commitCount: commits.length,
+    dateRange: {
+      from: dates[0] || "",
+      to: dates[dates.length - 1] || ""
+    },
+    languages: Array.from(languages),
+    frameworks: Array.from(frameworks),
+    summary
+  };
+}
+function getRecentBugFixes(repoPath, limit = 20) {
+  const result = analyzeGitHistory(repoPath, { commits: limit * 3 });
+  return result.patterns.filter((p) => p.category === "error_fix").slice(0, limit);
+}
+function getRecentRefactors(repoPath, limit = 20) {
+  const result = analyzeGitHistory(repoPath, { commits: limit * 3 });
+  return result.patterns.filter((p) => p.category === "refactor").slice(0, limit);
+}
+
+// src/session/session-explainer.ts
+function formatDuration(ms) {
+  const seconds = Math.floor(ms / 1e3);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  if (hours > 0) {
+    const remainMinutes = minutes % 60;
+    return `${hours}h ${remainMinutes}m`;
+  }
+  if (minutes > 0) {
+    return `${minutes}m`;
+  }
+  return `${seconds}s`;
+}
+var SessionExplainer = class {
+  projectPath;
+  sessionManager;
+  constructor(projectPath) {
+    this.projectPath = projectPath;
+    this.sessionManager = new SessionManager(projectPath);
+  }
+  explain(options) {
+    const state = this.sessionManager.get();
+    const includeGit = options?.includeGit !== false;
+    const explanation = {
+      date: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
+      agent: "unknown",
+      skillsUsed: [],
+      tasks: [],
+      filesModified: [],
+      decisions: [],
+      observationCounts: { errors: 0, solutions: 0, patterns: 0, total: 0 },
+      gitCommits: 0
+    };
+    if (!state) {
+      return explanation;
+    }
+    try {
+      const configAgent = loadConfig().agent;
+      if (configAgent && configAgent !== "universal") {
+        explanation.agent = configAgent;
+      } else if (state.currentExecution?.skillSource) {
+        explanation.agent = state.currentExecution.skillSource;
+      }
+    } catch {
+      if (state.currentExecution?.skillSource) {
+        explanation.agent = state.currentExecution.skillSource;
+      }
+    }
+    if (state.currentExecution) {
+      const exec2 = state.currentExecution;
+      const startTime = new Date(exec2.startedAt).getTime();
+      explanation.duration = formatDuration(Date.now() - startTime);
+      explanation.skillsUsed.push({
+        name: exec2.skillName,
+        status: exec2.status
+      });
+      for (const task of exec2.tasks) {
+        const taskEntry = {
+          name: task.name,
+          status: task.status
+        };
+        if (task.startedAt && task.completedAt) {
+          const dur = new Date(task.completedAt).getTime() - new Date(task.startedAt).getTime();
+          taskEntry.duration = formatDuration(dur);
+        }
+        explanation.tasks.push(taskEntry);
+        if (task.filesModified) {
+          explanation.filesModified.push(...task.filesModified);
+        }
+      }
+    }
+    for (const hist of state.history ?? []) {
+      const alreadyListed = explanation.skillsUsed.some(
+        (s) => s.name === hist.skillName
+      );
+      if (!alreadyListed) {
+        explanation.skillsUsed.push({
+          name: hist.skillName,
+          status: hist.status
+        });
+      }
+      if (hist.filesModified) {
+        explanation.filesModified.push(...hist.filesModified);
+      }
+    }
+    explanation.filesModified = [...new Set(explanation.filesModified)];
+    explanation.decisions = (state.decisions ?? []).map(({ key, value }) => ({ key, value }));
+    try {
+      const observations = ObservationStore.readAll(this.projectPath);
+      const countByType = (type) => observations.filter((o) => o.type === type).length;
+      explanation.observationCounts = {
+        total: observations.length,
+        errors: countByType("error"),
+        solutions: countByType("solution"),
+        patterns: countByType("pattern")
+      };
+    } catch {
+    }
+    if (includeGit) {
+      try {
+        const commits = getGitCommits(this.projectPath, { commits: 50 });
+        const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+        explanation.gitCommits = commits.filter(
+          (c) => c.date.startsWith(today)
+        ).length;
+      } catch {
+      }
+    }
+    return explanation;
+  }
+  formatText(explanation) {
+    const lines = [];
+    lines.push("  Session Summary\n");
+    if (explanation.duration) {
+      lines.push(`  Duration:   ${explanation.duration}`);
+    }
+    lines.push(`  Agent:      ${explanation.agent}`);
+    lines.push("");
+    if (explanation.skillsUsed.length > 0) {
+      lines.push("  Skills Used");
+      for (const skill of explanation.skillsUsed) {
+        const icon = skill.status === "completed" ? "\u2713" : "\u25CB";
+        lines.push(`    ${icon} ${skill.name} (${skill.status})`);
+      }
+      lines.push("");
+    }
+    if (explanation.tasks.length > 0) {
+      lines.push(`  Tasks (${explanation.tasks.length} total)`);
+      for (const task of explanation.tasks) {
+        const icon = task.status === "completed" ? "\u2713" : "\u25CB";
+        const dur = task.duration ? ` (${task.duration})` : "";
+        lines.push(`    ${icon} ${task.name}${dur}`);
+      }
+      lines.push("");
+    }
+    lines.push(`  Files Modified: ${explanation.filesModified.length} files`);
+    lines.push(`  Git Commits: ${explanation.gitCommits}`);
+    lines.push("");
+    if (explanation.decisions.length > 0) {
+      lines.push("  Decisions");
+      for (const d of explanation.decisions) {
+        lines.push(`    ${d.key} \u2192 ${d.value}`);
+      }
+      lines.push("");
+    }
+    const obs = explanation.observationCounts;
+    lines.push(
+      `  Observations: ${obs.errors} errors, ${obs.solutions} solutions, ${obs.patterns} patterns`
+    );
+    return lines.join("\n");
+  }
+  formatJson(explanation) {
+    return JSON.stringify(explanation, null, 2);
+  }
+};
+
 // src/workflow/types.ts
 var WORKFLOWS_DIR = "workflows";
 var WORKFLOW_EXTENSION = ".yaml";
@@ -8017,11 +8848,11 @@ function getBuiltinPipelines() {
 }
 
 // src/workflow/parser.ts
-import { existsSync as existsSync18, readFileSync as readFileSync10, readdirSync as readdirSync5, writeFileSync as writeFileSync9, mkdirSync as mkdirSync9 } from "fs";
-import { join as join17 } from "path";
-import { parse as parse2, stringify as stringify2 } from "yaml";
+import { existsSync as existsSync22, readFileSync as readFileSync13, readdirSync as readdirSync6, writeFileSync as writeFileSync12, mkdirSync as mkdirSync12 } from "fs";
+import { join as join21 } from "path";
+import { parse as parse4, stringify as stringify4 } from "yaml";
 function parseWorkflow(content) {
-  const data = parse2(content);
+  const data = parse4(content);
   if (!data.name || typeof data.name !== "string") {
     throw new Error("Workflow must have a name");
   }
@@ -8070,25 +8901,25 @@ function parseWorkflow(content) {
   };
 }
 function loadWorkflow(filePath) {
-  if (!existsSync18(filePath)) {
+  if (!existsSync22(filePath)) {
     throw new Error(`Workflow file not found: ${filePath}`);
   }
-  const content = readFileSync10(filePath, "utf-8");
+  const content = readFileSync13(filePath, "utf-8");
   return parseWorkflow(content);
 }
 function loadWorkflowByName(projectPath, name) {
-  const workflowsDir = join17(projectPath, ".skillkit", WORKFLOWS_DIR);
-  if (!existsSync18(workflowsDir)) {
+  const workflowsDir = join21(projectPath, ".skillkit", WORKFLOWS_DIR);
+  if (!existsSync22(workflowsDir)) {
     return null;
   }
-  const exactPath = join17(workflowsDir, `${name}${WORKFLOW_EXTENSION}`);
-  if (existsSync18(exactPath)) {
+  const exactPath = join21(workflowsDir, `${name}${WORKFLOW_EXTENSION}`);
+  if (existsSync22(exactPath)) {
     return loadWorkflow(exactPath);
   }
-  const files = readdirSync5(workflowsDir).filter((f) => f.endsWith(WORKFLOW_EXTENSION));
+  const files = readdirSync6(workflowsDir).filter((f) => f.endsWith(WORKFLOW_EXTENSION));
   for (const file of files) {
     try {
-      const workflow = loadWorkflow(join17(workflowsDir, file));
+      const workflow = loadWorkflow(join21(workflowsDir, file));
       if (workflow.name === name) {
         return workflow;
       }
@@ -8098,15 +8929,15 @@ function loadWorkflowByName(projectPath, name) {
   return null;
 }
 function listWorkflows(projectPath) {
-  const workflowsDir = join17(projectPath, ".skillkit", WORKFLOWS_DIR);
-  if (!existsSync18(workflowsDir)) {
+  const workflowsDir = join21(projectPath, ".skillkit", WORKFLOWS_DIR);
+  if (!existsSync22(workflowsDir)) {
     return [];
   }
-  const files = readdirSync5(workflowsDir).filter((f) => f.endsWith(WORKFLOW_EXTENSION));
+  const files = readdirSync6(workflowsDir).filter((f) => f.endsWith(WORKFLOW_EXTENSION));
   const workflows = [];
   for (const file of files) {
     try {
-      const workflow = loadWorkflow(join17(workflowsDir, file));
+      const workflow = loadWorkflow(join21(workflowsDir, file));
       workflows.push(workflow);
     } catch {
     }
@@ -8114,17 +8945,17 @@ function listWorkflows(projectPath) {
   return workflows;
 }
 function saveWorkflow(projectPath, workflow) {
-  const workflowsDir = join17(projectPath, ".skillkit", WORKFLOWS_DIR);
-  if (!existsSync18(workflowsDir)) {
-    mkdirSync9(workflowsDir, { recursive: true });
+  const workflowsDir = join21(projectPath, ".skillkit", WORKFLOWS_DIR);
+  if (!existsSync22(workflowsDir)) {
+    mkdirSync12(workflowsDir, { recursive: true });
   }
   const fileName = `${workflow.name.replace(/[^a-z0-9-]/gi, "-").toLowerCase()}${WORKFLOW_EXTENSION}`;
-  const filePath = join17(workflowsDir, fileName);
-  writeFileSync9(filePath, stringify2(workflow));
+  const filePath = join21(workflowsDir, fileName);
+  writeFileSync12(filePath, stringify4(workflow));
   return filePath;
 }
 function serializeWorkflow(workflow) {
-  return stringify2(workflow);
+  return stringify4(workflow);
 }
 function validateWorkflow(workflow) {
   const errors = [];
@@ -8173,7 +9004,7 @@ function createWorkflowTemplate(name, description) {
 }
 
 // src/workflow/orchestrator.ts
-import { randomUUID as randomUUID6 } from "crypto";
+import { randomUUID as randomUUID7 } from "crypto";
 var WorkflowOrchestrator = class {
   execution = null;
   executor;
@@ -8194,7 +9025,7 @@ var WorkflowOrchestrator = class {
   async execute(workflow) {
     this.execution = {
       workflow,
-      executionId: randomUUID6(),
+      executionId: randomUUID7(),
       status: "running",
       currentWave: 0,
       waves: workflow.waves.map((wave, index) => ({
@@ -8386,8 +9217,8 @@ function createWorkflowOrchestrator(executor, onProgress) {
 }
 
 // src/executor/engine.ts
-import { execSync as execSync5 } from "child_process";
-import { randomUUID as randomUUID7 } from "crypto";
+import { execSync as execSync6 } from "child_process";
+import { randomUUID as randomUUID8 } from "crypto";
 var SkillExecutionEngine = class {
   projectPath;
   sessionManager;
@@ -8612,7 +9443,7 @@ var SkillExecutionEngine = class {
    */
   async executeTask(task, _skill, _options) {
     const startTime = /* @__PURE__ */ new Date();
-    const taskId = task.id || randomUUID7();
+    const taskId = task.id || randomUUID8();
     try {
       await new Promise((resolve6) => setTimeout(resolve6, 100));
       const endTime = /* @__PURE__ */ new Date();
@@ -8726,7 +9557,7 @@ var SkillExecutionEngine = class {
       for (const rule of task.verify.automated) {
         if (rule.command) {
           try {
-            const output = execSync5(rule.command, {
+            const output = execSync6(rule.command, {
               cwd: this.projectPath,
               encoding: "utf-8",
               timeout: 3e4
@@ -8784,7 +9615,7 @@ var SkillExecutionEngine = class {
       completedAt: (/* @__PURE__ */ new Date()).toISOString(),
       durationMs: 0,
       tasks: tasks.map((task) => ({
-        taskId: task.id || randomUUID7(),
+        taskId: task.id || randomUUID8(),
         taskName: task.name,
         status: "skipped",
         startedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -9040,26 +9871,26 @@ To execute this skill manually:
 }
 
 // src/executor/skill-executor.ts
-import { existsSync as existsSync19 } from "fs";
-import { join as join18 } from "path";
+import { existsSync as existsSync23 } from "fs";
+import { join as join22 } from "path";
 import { homedir as homedir7 } from "os";
 function getSearchDirs2(projectPath) {
   const dirs = [];
   for (const searchPath of SKILL_DISCOVERY_PATHS) {
-    const fullPath = join18(projectPath, searchPath);
-    if (existsSync19(fullPath)) {
+    const fullPath = join22(projectPath, searchPath);
+    if (existsSync23(fullPath)) {
       dirs.push(fullPath);
     }
   }
   const home = homedir7();
   const globalPaths = [
-    join18(home, ".claude", "skills"),
-    join18(home, ".cursor", "skills"),
-    join18(home, ".codex", "skills"),
-    join18(home, ".skillkit", "skills")
+    join22(home, ".claude", "skills"),
+    join22(home, ".cursor", "skills"),
+    join22(home, ".codex", "skills"),
+    join22(home, ".skillkit", "skills")
   ];
   for (const globalPath of globalPaths) {
-    if (existsSync19(globalPath)) {
+    if (existsSync23(globalPath)) {
       dirs.push(globalPath);
     }
   }
@@ -9189,12 +10020,12 @@ function createSimulatedSkillExecutor(options = {}) {
 }
 
 // src/testing/runner.ts
-import { existsSync as existsSync20, readFileSync as readFileSync11 } from "fs";
-import { join as join19 } from "path";
+import { existsSync as existsSync24, readFileSync as readFileSync14 } from "fs";
+import { join as join23 } from "path";
 import { exec } from "child_process";
 import { createServer } from "net";
 import { promisify } from "util";
-import { parse as parseYaml6 } from "yaml";
+import { parse as parseYaml7 } from "yaml";
 var execAsync = promisify(exec);
 var DEFAULT_TIMEOUT = 3e4;
 async function runAssertion(assertion, cwd, timeout) {
@@ -9255,8 +10086,8 @@ async function runAssertion(assertion, cwd, timeout) {
   }
 }
 function assertFileExists(assertion, cwd, startTime) {
-  const filePath = join19(cwd, assertion.target || "");
-  const exists = existsSync20(filePath);
+  const filePath = join23(cwd, assertion.target || "");
+  const exists = existsSync24(filePath);
   return {
     assertion,
     passed: exists,
@@ -9267,8 +10098,8 @@ function assertFileExists(assertion, cwd, startTime) {
   };
 }
 function assertFileNotExists(assertion, cwd, startTime) {
-  const filePath = join19(cwd, assertion.target || "");
-  const exists = existsSync20(filePath);
+  const filePath = join23(cwd, assertion.target || "");
+  const exists = existsSync24(filePath);
   return {
     assertion,
     passed: !exists,
@@ -9279,8 +10110,8 @@ function assertFileNotExists(assertion, cwd, startTime) {
   };
 }
 function assertFileContains(assertion, cwd, startTime) {
-  const filePath = join19(cwd, assertion.target || "");
-  if (!existsSync20(filePath)) {
+  const filePath = join23(cwd, assertion.target || "");
+  if (!existsSync24(filePath)) {
     return {
       assertion,
       passed: false,
@@ -9288,7 +10119,7 @@ function assertFileContains(assertion, cwd, startTime) {
       duration: Date.now() - startTime
     };
   }
-  const content = readFileSync11(filePath, "utf-8");
+  const content = readFileSync14(filePath, "utf-8");
   const expected = String(assertion.expected || "");
   const contains = content.includes(expected);
   return {
@@ -9301,8 +10132,8 @@ function assertFileContains(assertion, cwd, startTime) {
   };
 }
 function assertFileNotContains(assertion, cwd, startTime) {
-  const filePath = join19(cwd, assertion.target || "");
-  if (!existsSync20(filePath)) {
+  const filePath = join23(cwd, assertion.target || "");
+  if (!existsSync24(filePath)) {
     return {
       assertion,
       passed: true,
@@ -9310,7 +10141,7 @@ function assertFileNotContains(assertion, cwd, startTime) {
       duration: Date.now() - startTime
     };
   }
-  const content = readFileSync11(filePath, "utf-8");
+  const content = readFileSync14(filePath, "utf-8");
   const expected = String(assertion.expected || "");
   const contains = content.includes(expected);
   return {
@@ -9323,8 +10154,8 @@ function assertFileNotContains(assertion, cwd, startTime) {
   };
 }
 function assertFileMatches(assertion, cwd, startTime) {
-  const filePath = join19(cwd, assertion.target || "");
-  if (!existsSync20(filePath)) {
+  const filePath = join23(cwd, assertion.target || "");
+  if (!existsSync24(filePath)) {
     return {
       assertion,
       passed: false,
@@ -9332,7 +10163,7 @@ function assertFileMatches(assertion, cwd, startTime) {
       duration: Date.now() - startTime
     };
   }
-  const content = readFileSync11(filePath, "utf-8");
+  const content = readFileSync14(filePath, "utf-8");
   const pattern = new RegExp(String(assertion.expected || ""));
   const matches = pattern.test(content);
   return {
@@ -9419,8 +10250,8 @@ async function assertCommandOutputContains(assertion, cwd, timeout, startTime) {
   }
 }
 function assertJsonValid(assertion, cwd, startTime) {
-  const filePath = join19(cwd, assertion.target || "");
-  if (!existsSync20(filePath)) {
+  const filePath = join23(cwd, assertion.target || "");
+  if (!existsSync24(filePath)) {
     return {
       assertion,
       passed: false,
@@ -9429,7 +10260,7 @@ function assertJsonValid(assertion, cwd, startTime) {
     };
   }
   try {
-    const content = readFileSync11(filePath, "utf-8");
+    const content = readFileSync14(filePath, "utf-8");
     JSON.parse(content);
     return {
       assertion,
@@ -9450,8 +10281,8 @@ function assertJsonValid(assertion, cwd, startTime) {
   }
 }
 function assertJsonHasKey(assertion, cwd, startTime) {
-  const filePath = join19(cwd, assertion.target || "");
-  if (!existsSync20(filePath)) {
+  const filePath = join23(cwd, assertion.target || "");
+  if (!existsSync24(filePath)) {
     return {
       assertion,
       passed: false,
@@ -9460,7 +10291,7 @@ function assertJsonHasKey(assertion, cwd, startTime) {
     };
   }
   try {
-    const content = readFileSync11(filePath, "utf-8");
+    const content = readFileSync14(filePath, "utf-8");
     const json = JSON.parse(content);
     const key = String(assertion.expected || "");
     const keys = key.split(".");
@@ -9495,8 +10326,8 @@ function assertJsonHasKey(assertion, cwd, startTime) {
   }
 }
 function assertYamlValid(assertion, cwd, startTime) {
-  const filePath = join19(cwd, assertion.target || "");
-  if (!existsSync20(filePath)) {
+  const filePath = join23(cwd, assertion.target || "");
+  if (!existsSync24(filePath)) {
     return {
       assertion,
       passed: false,
@@ -9505,8 +10336,8 @@ function assertYamlValid(assertion, cwd, startTime) {
     };
   }
   try {
-    const content = readFileSync11(filePath, "utf-8");
-    parseYaml6(content);
+    const content = readFileSync14(filePath, "utf-8");
+    parseYaml7(content);
     return {
       assertion,
       passed: true,
@@ -10028,8 +10859,8 @@ var MARKETPLACE_CACHE_FILE = "marketplace-index.json";
 var DEFAULT_CACHE_TTL = 60 * 60 * 1e3;
 
 // src/marketplace/aggregator.ts
-import { existsSync as existsSync21, readFileSync as readFileSync12, writeFileSync as writeFileSync10, mkdirSync as mkdirSync10, unlinkSync as unlinkSync2 } from "fs";
-import { join as join20 } from "path";
+import { existsSync as existsSync25, readFileSync as readFileSync15, writeFileSync as writeFileSync13, mkdirSync as mkdirSync13, unlinkSync as unlinkSync3 } from "fs";
+import { join as join24 } from "path";
 import { homedir as homedir8 } from "os";
 var MarketplaceAggregator = class {
   config;
@@ -10038,10 +10869,10 @@ var MarketplaceAggregator = class {
   index = null;
   constructor(config = {}) {
     this.config = config;
-    this.cacheDir = config.cacheDir || join20(homedir8(), ".skillkit", "marketplace");
-    this.cachePath = join20(this.cacheDir, MARKETPLACE_CACHE_FILE);
-    if (!existsSync21(this.cacheDir)) {
-      mkdirSync10(this.cacheDir, { recursive: true });
+    this.cacheDir = config.cacheDir || join24(homedir8(), ".skillkit", "marketplace");
+    this.cachePath = join24(this.cacheDir, MARKETPLACE_CACHE_FILE);
+    if (!existsSync25(this.cacheDir)) {
+      mkdirSync13(this.cacheDir, { recursive: true });
     }
   }
   /**
@@ -10054,11 +10885,11 @@ var MarketplaceAggregator = class {
    * Load cached index
    */
   loadCache() {
-    if (!existsSync21(this.cachePath)) {
+    if (!existsSync25(this.cachePath)) {
       return null;
     }
     try {
-      const content = readFileSync12(this.cachePath, "utf-8");
+      const content = readFileSync15(this.cachePath, "utf-8");
       const index = JSON.parse(content);
       const cacheAge = Date.now() - new Date(index.updatedAt).getTime();
       const ttl = this.config.cacheTTL || DEFAULT_CACHE_TTL;
@@ -10075,7 +10906,7 @@ var MarketplaceAggregator = class {
    * Save index to cache
    */
   saveCache(index) {
-    writeFileSync10(this.cachePath, JSON.stringify(index, null, 2));
+    writeFileSync13(this.cachePath, JSON.stringify(index, null, 2));
     this.index = index;
   }
   /**
@@ -10399,8 +11230,8 @@ var MarketplaceAggregator = class {
    * Clear cache
    */
   clearCache() {
-    if (existsSync21(this.cachePath)) {
-      unlinkSync2(this.cachePath);
+    if (existsSync25(this.cachePath)) {
+      unlinkSync3(this.cachePath);
     }
     this.index = null;
   }
@@ -10624,203 +11455,9 @@ var DEFAULT_MEMORY_CONFIG = {
   maxLearnings: 500
 };
 
-// src/memory/observation-store.ts
-import { existsSync as existsSync22, mkdirSync as mkdirSync11, readFileSync as readFileSync13, writeFileSync as writeFileSync11 } from "fs";
-import { dirname as dirname4, join as join21 } from "path";
-import { parse as parseYaml7, stringify as stringifyYaml5 } from "yaml";
-import { randomUUID as randomUUID8 } from "crypto";
-var ObservationStore = class {
-  filePath;
-  projectPath;
-  data = null;
-  sessionId;
-  compressionThreshold;
-  autoCompress;
-  onThresholdReached;
-  compressionInProgress = false;
-  constructor(projectPath, sessionId, options = {}) {
-    this.projectPath = projectPath;
-    this.filePath = join21(projectPath, ".skillkit", "memory", "observations.yaml");
-    this.sessionId = sessionId || randomUUID8();
-    this.compressionThreshold = options.compressionThreshold ?? 50;
-    this.autoCompress = options.autoCompress ?? true;
-    this.onThresholdReached = options.onThresholdReached;
-  }
-  ensureDir() {
-    const dir = dirname4(this.filePath);
-    if (!existsSync22(dir)) {
-      mkdirSync11(dir, { recursive: true });
-    }
-  }
-  load() {
-    if (this.data) return this.data;
-    if (existsSync22(this.filePath)) {
-      try {
-        const content = readFileSync13(this.filePath, "utf-8");
-        this.data = parseYaml7(content);
-        if (this.data.sessionId !== this.sessionId) {
-          this.data.sessionId = this.sessionId;
-          this.data.observations = [];
-        }
-      } catch {
-        this.data = this.createEmpty();
-      }
-    } else {
-      this.data = this.createEmpty();
-    }
-    return this.data;
-  }
-  createEmpty() {
-    return {
-      version: 1,
-      sessionId: this.sessionId,
-      observations: []
-    };
-  }
-  save() {
-    this.ensureDir();
-    const content = stringifyYaml5(this.data, { lineWidth: 0 });
-    writeFileSync11(this.filePath, content, "utf-8");
-  }
-  add(type, content, agent, relevance = 50) {
-    const data = this.load();
-    const observation = {
-      id: randomUUID8(),
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      sessionId: this.sessionId,
-      agent,
-      type,
-      content,
-      relevance
-    };
-    data.observations.push(observation);
-    this.save();
-    void this.checkAutoCompression().catch(() => {
-    });
-    return observation;
-  }
-  /**
-   * Check if auto-compression should trigger
-   */
-  async checkAutoCompression() {
-    if (!this.autoCompress || this.compressionInProgress) return;
-    if (!this.onThresholdReached) return;
-    const count = this.count();
-    if (count >= this.compressionThreshold) {
-      this.compressionInProgress = true;
-      try {
-        const observations = this.getAll();
-        await this.onThresholdReached(observations);
-      } finally {
-        this.compressionInProgress = false;
-      }
-    }
-  }
-  /**
-   * Set auto-compression callback
-   */
-  setAutoCompressCallback(callback) {
-    this.onThresholdReached = callback;
-  }
-  /**
-   * Enable/disable auto-compression
-   */
-  setAutoCompress(enabled) {
-    this.autoCompress = enabled;
-  }
-  /**
-   * Set compression threshold
-   */
-  setCompressionThreshold(threshold) {
-    if (threshold < 1 || !Number.isInteger(threshold)) {
-      throw new Error("Compression threshold must be a positive integer");
-    }
-    this.compressionThreshold = threshold;
-  }
-  /**
-   * Get compression threshold
-   */
-  getCompressionThreshold() {
-    return this.compressionThreshold;
-  }
-  /**
-   * Check if threshold is reached
-   */
-  isThresholdReached() {
-    return this.count() >= this.compressionThreshold;
-  }
-  /**
-   * Get project path
-   */
-  getProjectPath() {
-    return this.projectPath;
-  }
-  getAll() {
-    return this.load().observations;
-  }
-  getByType(type) {
-    return this.load().observations.filter((o) => o.type === type);
-  }
-  getByRelevance(minRelevance) {
-    return this.load().observations.filter((o) => o.relevance >= minRelevance);
-  }
-  getRecent(count) {
-    const observations = this.load().observations;
-    return observations.slice(-count);
-  }
-  getUncompressed(compressedIds) {
-    const compressedSet = new Set(compressedIds);
-    return this.load().observations.filter((o) => !compressedSet.has(o.id));
-  }
-  count() {
-    return this.load().observations.length;
-  }
-  clear() {
-    this.data = this.createEmpty();
-    this.save();
-  }
-  getById(id) {
-    return this.load().observations.find((o) => o.id === id);
-  }
-  getByIds(ids) {
-    const idSet = new Set(ids);
-    return this.load().observations.filter((o) => idSet.has(o.id));
-  }
-  getSessionId() {
-    return this.sessionId;
-  }
-  setSessionId(sessionId) {
-    this.sessionId = sessionId;
-    if (this.data) {
-      this.data.sessionId = sessionId;
-    }
-  }
-  exists() {
-    return existsSync22(this.filePath);
-  }
-  delete(id) {
-    const data = this.load();
-    const index = data.observations.findIndex((o) => o.id === id);
-    if (index === -1) return false;
-    data.observations.splice(index, 1);
-    this.save();
-    return true;
-  }
-  deleteMany(ids) {
-    const idSet = new Set(ids);
-    const data = this.load();
-    const initialLength = data.observations.length;
-    data.observations = data.observations.filter((o) => !idSet.has(o.id));
-    if (data.observations.length !== initialLength) {
-      this.save();
-    }
-    return initialLength - data.observations.length;
-  }
-};
-
 // src/memory/learning-store.ts
-import { existsSync as existsSync23, mkdirSync as mkdirSync12, readFileSync as readFileSync14, writeFileSync as writeFileSync12 } from "fs";
-import { dirname as dirname5, join as join22 } from "path";
+import { existsSync as existsSync26, mkdirSync as mkdirSync14, readFileSync as readFileSync16, writeFileSync as writeFileSync14 } from "fs";
+import { dirname as dirname5, join as join25 } from "path";
 import { homedir as homedir9 } from "os";
 import { parse as parseYaml8, stringify as stringifyYaml6 } from "yaml";
 import { randomUUID as randomUUID9 } from "crypto";
@@ -10833,22 +11470,22 @@ var LearningStore = class {
     this.scope = scope;
     this.projectName = projectName;
     if (scope === "project" && projectPath) {
-      this.filePath = join22(projectPath, ".skillkit", "memory", "learnings.yaml");
+      this.filePath = join25(projectPath, ".skillkit", "memory", "learnings.yaml");
     } else {
-      this.filePath = join22(homedir9(), ".skillkit", "memory", "global.yaml");
+      this.filePath = join25(homedir9(), ".skillkit", "memory", "global.yaml");
     }
   }
   ensureDir() {
     const dir = dirname5(this.filePath);
-    if (!existsSync23(dir)) {
-      mkdirSync12(dir, { recursive: true });
+    if (!existsSync26(dir)) {
+      mkdirSync14(dir, { recursive: true });
     }
   }
   load() {
     if (this.data) return this.data;
-    if (existsSync23(this.filePath)) {
+    if (existsSync26(this.filePath)) {
       try {
-        const content = readFileSync14(this.filePath, "utf-8");
+        const content = readFileSync16(this.filePath, "utf-8");
         this.data = parseYaml8(content);
       } catch {
         this.data = this.createEmpty();
@@ -10867,7 +11504,7 @@ var LearningStore = class {
   save() {
     this.ensureDir();
     const content = stringifyYaml6(this.data, { lineWidth: 0 });
-    writeFileSync12(this.filePath, content, "utf-8");
+    writeFileSync14(this.filePath, content, "utf-8");
   }
   add(learning) {
     const data = this.load();
@@ -10974,7 +11611,7 @@ var LearningStore = class {
     this.save();
   }
   exists() {
-    return existsSync23(this.filePath);
+    return existsSync26(this.filePath);
   }
   getScope() {
     return this.scope;
@@ -10982,26 +11619,26 @@ var LearningStore = class {
 };
 
 // src/memory/memory-index.ts
-import { existsSync as existsSync24, mkdirSync as mkdirSync13, readFileSync as readFileSync15, writeFileSync as writeFileSync13 } from "fs";
-import { dirname as dirname6, join as join23 } from "path";
+import { existsSync as existsSync27, mkdirSync as mkdirSync15, readFileSync as readFileSync17, writeFileSync as writeFileSync15 } from "fs";
+import { dirname as dirname6, join as join26 } from "path";
 import { parse as parseYaml9, stringify as stringifyYaml7 } from "yaml";
 var MemoryIndexStore = class {
   filePath;
   data = null;
   constructor(basePath, _isGlobal = false) {
-    this.filePath = join23(basePath, ".skillkit", "memory", "index.yaml");
+    this.filePath = join26(basePath, ".skillkit", "memory", "index.yaml");
   }
   ensureDir() {
     const dir = dirname6(this.filePath);
-    if (!existsSync24(dir)) {
-      mkdirSync13(dir, { recursive: true });
+    if (!existsSync27(dir)) {
+      mkdirSync15(dir, { recursive: true });
     }
   }
   load() {
     if (this.data) return this.data;
-    if (existsSync24(this.filePath)) {
+    if (existsSync27(this.filePath)) {
       try {
-        const content = readFileSync15(this.filePath, "utf-8");
+        const content = readFileSync17(this.filePath, "utf-8");
         this.data = parseYaml9(content);
       } catch {
         this.data = this.createEmpty();
@@ -11025,7 +11662,7 @@ var MemoryIndexStore = class {
       this.data.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
     }
     const content = stringifyYaml7(this.data, { lineWidth: 0 });
-    writeFileSync13(this.filePath, content, "utf-8");
+    writeFileSync15(this.filePath, content, "utf-8");
   }
   extractKeywords(text) {
     const stopWords = /* @__PURE__ */ new Set([
@@ -11219,7 +11856,7 @@ var MemoryIndexStore = class {
     this.save();
   }
   exists() {
-    return existsSync24(this.filePath);
+    return existsSync27(this.filePath);
   }
   getStats() {
     const data = this.load();
@@ -11232,50 +11869,50 @@ var MemoryIndexStore = class {
 };
 
 // src/memory/initializer.ts
-import { existsSync as existsSync25, mkdirSync as mkdirSync14 } from "fs";
-import { join as join24 } from "path";
+import { existsSync as existsSync28, mkdirSync as mkdirSync16 } from "fs";
+import { join as join27 } from "path";
 import { homedir as homedir10 } from "os";
 function getMemoryPaths(projectPath) {
-  const projectMemoryDir = join24(projectPath, ".skillkit", "memory");
-  const globalMemoryDir = join24(homedir10(), ".skillkit", "memory");
+  const projectMemoryDir = join27(projectPath, ".skillkit", "memory");
+  const globalMemoryDir = join27(homedir10(), ".skillkit", "memory");
   return {
     projectMemoryDir,
     globalMemoryDir,
-    observationsFile: join24(projectMemoryDir, "observations.yaml"),
-    learningsFile: join24(projectMemoryDir, "learnings.yaml"),
-    indexFile: join24(projectMemoryDir, "index.yaml"),
-    globalLearningsFile: join24(globalMemoryDir, "global.yaml"),
-    globalIndexFile: join24(globalMemoryDir, "index.yaml")
+    observationsFile: join27(projectMemoryDir, "observations.yaml"),
+    learningsFile: join27(projectMemoryDir, "learnings.yaml"),
+    indexFile: join27(projectMemoryDir, "index.yaml"),
+    globalLearningsFile: join27(globalMemoryDir, "global.yaml"),
+    globalIndexFile: join27(globalMemoryDir, "index.yaml")
   };
 }
 function initializeMemoryDirectory(projectPath) {
   const paths = getMemoryPaths(projectPath);
-  if (!existsSync25(paths.projectMemoryDir)) {
-    mkdirSync14(paths.projectMemoryDir, { recursive: true });
+  if (!existsSync28(paths.projectMemoryDir)) {
+    mkdirSync16(paths.projectMemoryDir, { recursive: true });
   }
-  if (!existsSync25(paths.globalMemoryDir)) {
-    mkdirSync14(paths.globalMemoryDir, { recursive: true });
+  if (!existsSync28(paths.globalMemoryDir)) {
+    mkdirSync16(paths.globalMemoryDir, { recursive: true });
   }
   return paths;
 }
 function memoryDirectoryExists(projectPath) {
   const paths = getMemoryPaths(projectPath);
-  return existsSync25(paths.projectMemoryDir);
+  return existsSync28(paths.projectMemoryDir);
 }
 function globalMemoryDirectoryExists() {
-  const globalMemoryDir = join24(homedir10(), ".skillkit", "memory");
-  return existsSync25(globalMemoryDir);
+  const globalMemoryDir = join27(homedir10(), ".skillkit", "memory");
+  return existsSync28(globalMemoryDir);
 }
 function getMemoryStatus(projectPath) {
   const paths = getMemoryPaths(projectPath);
   return {
-    projectMemoryExists: existsSync25(paths.projectMemoryDir),
-    globalMemoryExists: existsSync25(paths.globalMemoryDir),
-    hasObservations: existsSync25(paths.observationsFile),
-    hasLearnings: existsSync25(paths.learningsFile),
-    hasGlobalLearnings: existsSync25(paths.globalLearningsFile),
-    hasIndex: existsSync25(paths.indexFile),
-    hasGlobalIndex: existsSync25(paths.globalIndexFile)
+    projectMemoryExists: existsSync28(paths.projectMemoryDir),
+    globalMemoryExists: existsSync28(paths.globalMemoryDir),
+    hasObservations: existsSync28(paths.observationsFile),
+    hasLearnings: existsSync28(paths.learningsFile),
+    hasGlobalLearnings: existsSync28(paths.globalLearningsFile),
+    hasIndex: existsSync28(paths.indexFile),
+    hasGlobalIndex: existsSync28(paths.globalIndexFile)
   };
 }
 
@@ -13961,8 +14598,8 @@ function createMemoryHookManager(projectPath, agent = "claude-code", config = {}
 }
 
 // src/memory/claude-md-updater.ts
-import { existsSync as existsSync26, readFileSync as readFileSync16, writeFileSync as writeFileSync14, mkdirSync as mkdirSync15 } from "fs";
-import { join as join25, dirname as dirname7, basename as basename11 } from "path";
+import { existsSync as existsSync29, readFileSync as readFileSync18, writeFileSync as writeFileSync16, mkdirSync as mkdirSync17 } from "fs";
+import { join as join28, dirname as dirname7, basename as basename11 } from "path";
 import { homedir as homedir12 } from "os";
 var SKILLKIT_MARKER = "<!-- Auto-populated by SkillKit -->";
 var DEFAULT_UPDATE_OPTIONS = {
@@ -13978,20 +14615,20 @@ var ClaudeMdUpdater = class {
   claudeMdPath;
   constructor(projectPath, claudeMdPath) {
     this.projectPath = projectPath;
-    this.claudeMdPath = claudeMdPath || join25(projectPath, "CLAUDE.md");
+    this.claudeMdPath = claudeMdPath || join28(projectPath, "CLAUDE.md");
   }
   /**
    * Parse CLAUDE.md to extract structure
    */
   parse() {
-    if (!existsSync26(this.claudeMdPath)) {
+    if (!existsSync29(this.claudeMdPath)) {
       return {
         content: "",
         sections: /* @__PURE__ */ new Map(),
         hasLearnedSection: false
       };
     }
-    const content = readFileSync16(this.claudeMdPath, "utf-8");
+    const content = readFileSync18(this.claudeMdPath, "utf-8");
     const sections = /* @__PURE__ */ new Map();
     const lines = content.split("\n");
     let currentSection = null;
@@ -14118,10 +14755,10 @@ var ClaudeMdUpdater = class {
       newContent = this.createNewClaudeMd(newSection);
     }
     const dir = dirname7(this.claudeMdPath);
-    if (!existsSync26(dir)) {
-      mkdirSync15(dir, { recursive: true });
+    if (!existsSync29(dir)) {
+      mkdirSync17(dir, { recursive: true });
     }
-    writeFileSync14(this.claudeMdPath, newContent, "utf-8");
+    writeFileSync16(this.claudeMdPath, newContent, "utf-8");
     return {
       updated: true,
       path: this.claudeMdPath,
@@ -14146,7 +14783,7 @@ var ClaudeMdUpdater = class {
    * Check if CLAUDE.md exists
    */
   exists() {
-    return existsSync26(this.claudeMdPath);
+    return existsSync29(this.claudeMdPath);
   }
   /**
    * Get CLAUDE.md path
@@ -14250,7 +14887,7 @@ function updateClaudeMd(projectPath, options = {}) {
   return updater.update(options);
 }
 function syncGlobalClaudeMd(options = {}) {
-  const globalClaudeMdPath = join25(homedir12(), ".claude", "CLAUDE.md");
+  const globalClaudeMdPath = join28(homedir12(), ".claude", "CLAUDE.md");
   const updater = new ClaudeMdUpdater(homedir12(), globalClaudeMdPath);
   const globalOpts = {
     ...options,
@@ -14570,9 +15207,9 @@ function createProgressiveDisclosureManager(projectPath, projectName) {
 }
 
 // src/team/manager.ts
-import { existsSync as existsSync27, readFileSync as readFileSync17, writeFileSync as writeFileSync15, mkdirSync as mkdirSync16 } from "fs";
-import { join as join26, dirname as dirname8 } from "path";
-import { execSync as execSync6 } from "child_process";
+import { existsSync as existsSync30, readFileSync as readFileSync19, writeFileSync as writeFileSync17, mkdirSync as mkdirSync18 } from "fs";
+import { join as join29, dirname as dirname8 } from "path";
+import { execSync as execSync7 } from "child_process";
 import { parse as yamlParse, stringify as yamlStringify } from "yaml";
 var TEAM_CONFIG_FILE = "team.yaml";
 var TEAM_DIR = ".skillkit/team";
@@ -14592,9 +15229,9 @@ var TeamManager = class {
       ...config,
       teamId
     };
-    const teamDir = join26(this.projectPath, TEAM_DIR);
-    if (!existsSync27(teamDir)) {
-      mkdirSync16(teamDir, { recursive: true });
+    const teamDir = join29(this.projectPath, TEAM_DIR);
+    if (!existsSync30(teamDir)) {
+      mkdirSync18(teamDir, { recursive: true });
     }
     this.saveConfig(fullConfig);
     this.config = fullConfig;
@@ -14614,12 +15251,12 @@ var TeamManager = class {
    * Load existing team configuration
    */
   load() {
-    const configPath = join26(this.projectPath, TEAM_DIR, TEAM_CONFIG_FILE);
-    if (!existsSync27(configPath)) {
+    const configPath = join29(this.projectPath, TEAM_DIR, TEAM_CONFIG_FILE);
+    if (!existsSync30(configPath)) {
       return null;
     }
     try {
-      const content = readFileSync17(configPath, "utf-8");
+      const content = readFileSync19(configPath, "utf-8");
       this.config = this.parseYaml(content);
       this.loadRegistry();
       return this.config;
@@ -14650,8 +15287,8 @@ var TeamManager = class {
     if (!skillPath) {
       throw new Error(`Skill "${options.skillName}" not found locally.`);
     }
-    const skillMdPath = join26(skillPath, "SKILL.md");
-    const skillContent = existsSync27(skillMdPath) ? readFileSync17(skillMdPath, "utf-8") : "";
+    const skillMdPath = join29(skillPath, "SKILL.md");
+    const skillContent = existsSync30(skillMdPath) ? readFileSync19(skillMdPath, "utf-8") : "";
     const metadata = this.extractFrontmatter(skillContent);
     const shared = {
       name: options.skillName,
@@ -14716,7 +15353,7 @@ var TeamManager = class {
     if (options.dryRun) {
       return {
         success: true,
-        path: join26(this.projectPath, ".skillkit", "skills", skillName)
+        path: join29(this.projectPath, ".skillkit", "skills", skillName)
       };
     }
     try {
@@ -14766,9 +15403,9 @@ var TeamManager = class {
       if (!fetchResult.success || !fetchResult.path) {
         throw new Error(fetchResult.error || "Failed to fetch remote registry");
       }
-      const remoteRegistryPath = join26(fetchResult.path, TEAM_DIR, "registry.yaml");
-      if (existsSync27(remoteRegistryPath)) {
-        const remoteContent = readFileSync17(remoteRegistryPath, "utf-8");
+      const remoteRegistryPath = join29(fetchResult.path, TEAM_DIR, "registry.yaml");
+      if (existsSync30(remoteRegistryPath)) {
+        const remoteContent = readFileSync19(remoteRegistryPath, "utf-8");
         const remoteRegistry = this.parseYaml(remoteContent);
         const localSkillNames = new Set(this.registry?.skills.map((s) => s.name) || []);
         for (const skill of remoteRegistry.skills) {
@@ -14814,32 +15451,32 @@ var TeamManager = class {
     return `team-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
   }
   saveConfig(config) {
-    const configPath = join26(this.projectPath, TEAM_DIR, TEAM_CONFIG_FILE);
+    const configPath = join29(this.projectPath, TEAM_DIR, TEAM_CONFIG_FILE);
     const dir = dirname8(configPath);
-    if (!existsSync27(dir)) {
-      mkdirSync16(dir, { recursive: true });
+    if (!existsSync30(dir)) {
+      mkdirSync18(dir, { recursive: true });
     }
-    writeFileSync15(configPath, this.toYaml(config), "utf-8");
+    writeFileSync17(configPath, this.toYaml(config), "utf-8");
   }
   loadRegistry() {
-    const registryPath = join26(this.projectPath, TEAM_DIR, "registry.yaml");
-    if (existsSync27(registryPath)) {
-      const content = readFileSync17(registryPath, "utf-8");
+    const registryPath = join29(this.projectPath, TEAM_DIR, "registry.yaml");
+    if (existsSync30(registryPath)) {
+      const content = readFileSync19(registryPath, "utf-8");
       this.registry = this.parseYaml(content);
     }
   }
   saveRegistry(registry) {
-    const registryPath = join26(this.projectPath, TEAM_DIR, "registry.yaml");
-    writeFileSync15(registryPath, this.toYaml(registry), "utf-8");
+    const registryPath = join29(this.projectPath, TEAM_DIR, "registry.yaml");
+    writeFileSync17(registryPath, this.toYaml(registry), "utf-8");
   }
   findLocalSkill(skillName) {
     const possiblePaths = [
-      join26(this.projectPath, ".skillkit", "skills", skillName),
-      join26(this.projectPath, "skills", skillName),
-      join26(this.projectPath, ".claude", "skills", skillName)
+      join29(this.projectPath, ".skillkit", "skills", skillName),
+      join29(this.projectPath, "skills", skillName),
+      join29(this.projectPath, ".claude", "skills", skillName)
     ];
     for (const p of possiblePaths) {
-      if (existsSync27(p)) {
+      if (existsSync30(p)) {
         return p;
       }
     }
@@ -14847,8 +15484,8 @@ var TeamManager = class {
   }
   getAuthor() {
     try {
-      const name = execSync6("git config user.name", { encoding: "utf-8" }).trim();
-      const email = execSync6("git config user.email", { encoding: "utf-8" }).trim();
+      const name = execSync7("git config user.name", { encoding: "utf-8" }).trim();
+      const email = execSync7("git config user.email", { encoding: "utf-8" }).trim();
       return email ? `${name} <${email}>` : name;
     } catch {
       return "Unknown";
@@ -14856,13 +15493,13 @@ var TeamManager = class {
   }
   detectCompatibleAgents(skillPath) {
     const agents = [];
-    if (existsSync27(join26(skillPath, "SKILL.md"))) {
+    if (existsSync30(join29(skillPath, "SKILL.md"))) {
       agents.push("claude-code", "codex", "gemini-cli", "universal");
     }
-    if (existsSync27(join26(skillPath, "skill.mdc"))) {
+    if (existsSync30(join29(skillPath, "skill.mdc"))) {
       agents.push("cursor");
     }
-    if (existsSync27(join26(skillPath, "rules.md"))) {
+    if (existsSync30(join29(skillPath, "rules.md"))) {
       agents.push("windsurf");
     }
     return agents.length > 0 ? agents : ["universal"];
@@ -14888,8 +15525,8 @@ function createTeamManager(projectPath) {
 }
 
 // src/team/bundle.ts
-import { existsSync as existsSync28, readFileSync as readFileSync18, writeFileSync as writeFileSync16, mkdirSync as mkdirSync17, readdirSync as readdirSync6, statSync as statSync3 } from "fs";
-import { join as join27, basename as basename12, resolve as resolve4, relative, dirname as dirname9, sep as sep3 } from "path";
+import { existsSync as existsSync31, readFileSync as readFileSync20, writeFileSync as writeFileSync18, mkdirSync as mkdirSync19, readdirSync as readdirSync7, statSync as statSync3 } from "fs";
+import { join as join30, basename as basename12, resolve as resolve4, relative, dirname as dirname9, sep as sep3 } from "path";
 import { createHash } from "crypto";
 var BUNDLE_VERSION = 1;
 var SkillBundle = class {
@@ -14971,15 +15608,15 @@ var SkillBundle = class {
   readSkillContent(skillPath) {
     const contents = [];
     const readDir = (dir, prefix = "") => {
-      const entries = readdirSync6(dir);
+      const entries = readdirSync7(dir);
       for (const entry of entries) {
-        const fullPath = join27(dir, entry);
+        const fullPath = join30(dir, entry);
         const relativePath = prefix ? `${prefix}/${entry}` : entry;
         const stat = statSync3(fullPath);
         if (stat.isDirectory()) {
           readDir(fullPath, relativePath);
         } else if (stat.isFile()) {
-          const content = readFileSync18(fullPath, "utf-8");
+          const content = readFileSync20(fullPath, "utf-8");
           contents.push(`--- ${relativePath} ---
 ${content}`);
         }
@@ -14988,13 +15625,13 @@ ${content}`);
     if (statSync3(skillPath).isDirectory()) {
       readDir(skillPath);
     } else {
-      contents.push(readFileSync18(skillPath, "utf-8"));
+      contents.push(readFileSync20(skillPath, "utf-8"));
     }
     return contents.join("\n\n");
   }
   detectAgents(skillPath) {
     const agents = [];
-    if (existsSync28(skillPath) && statSync3(skillPath).isFile()) {
+    if (existsSync31(skillPath) && statSync3(skillPath).isFile()) {
       const fileName = basename12(skillPath).toLowerCase();
       if (fileName === "skill.md") {
         return ["claude-code", "codex", "gemini-cli", "universal"];
@@ -15007,13 +15644,13 @@ ${content}`);
       }
       return ["universal"];
     }
-    if (existsSync28(join27(skillPath, "SKILL.md"))) {
+    if (existsSync31(join30(skillPath, "SKILL.md"))) {
       agents.push("claude-code", "codex", "gemini-cli", "universal");
     }
-    if (existsSync28(join27(skillPath, "skill.mdc"))) {
+    if (existsSync31(join30(skillPath, "skill.mdc"))) {
       agents.push("cursor");
     }
-    if (existsSync28(join27(skillPath, "rules.md"))) {
+    if (existsSync31(join30(skillPath, "rules.md"))) {
       agents.push("windsurf");
     }
     return agents.length > 0 ? agents : ["universal"];
@@ -15036,10 +15673,10 @@ function exportBundle(bundle, outputPath) {
       }
     }
     const dir = dirname9(outputPath);
-    if (dir && !existsSync28(dir)) {
-      mkdirSync17(dir, { recursive: true });
+    if (dir && !existsSync31(dir)) {
+      mkdirSync19(dir, { recursive: true });
     }
-    writeFileSync16(outputPath, JSON.stringify(exportData, null, 2), "utf-8");
+    writeFileSync18(outputPath, JSON.stringify(exportData, null, 2), "utf-8");
     return { success: true, path: outputPath };
   } catch (err) {
     return {
@@ -15052,7 +15689,7 @@ function importBundle(bundlePath, targetDir, options = {}) {
   const imported = [];
   const errors = [];
   try {
-    const content = readFileSync18(bundlePath, "utf-8");
+    const content = readFileSync20(bundlePath, "utf-8");
     const data = JSON.parse(content);
     const absoluteTargetDir = resolve4(targetDir);
     for (const skill of data.manifest.skills) {
@@ -15065,19 +15702,19 @@ function importBundle(bundlePath, targetDir, options = {}) {
         errors.push(`Skill "${skill.name}" has no content in bundle`);
         continue;
       }
-      const skillDir = join27(absoluteTargetDir, skill.name);
+      const skillDir = join30(absoluteTargetDir, skill.name);
       const resolvedSkillDir = resolve4(skillDir);
       const relativeToTarget = relative(absoluteTargetDir, resolvedSkillDir);
       if (relativeToTarget.startsWith("..") || relativeToTarget.startsWith(sep3)) {
         errors.push(`Skill "${skill.name}" would escape target directory`);
         continue;
       }
-      if (existsSync28(skillDir) && !options.overwrite) {
+      if (existsSync31(skillDir) && !options.overwrite) {
         errors.push(`Skill "${skill.name}" already exists (use --overwrite)`);
         continue;
       }
-      if (!existsSync28(skillDir)) {
-        mkdirSync17(skillDir, { recursive: true });
+      if (!existsSync31(skillDir)) {
+        mkdirSync19(skillDir, { recursive: true });
       }
       const files = parseSkillContent2(skillContent);
       for (const [filePath, fileContent] of Object.entries(files)) {
@@ -15088,10 +15725,10 @@ function importBundle(bundlePath, targetDir, options = {}) {
           continue;
         }
         const fileDir = dirname9(fullPath);
-        if (!existsSync28(fileDir)) {
-          mkdirSync17(fileDir, { recursive: true });
+        if (!existsSync31(fileDir)) {
+          mkdirSync19(fileDir, { recursive: true });
         }
-        writeFileSync16(fullPath, fileContent, "utf-8");
+        writeFileSync18(fullPath, fileContent, "utf-8");
       }
       imported.push(skill.name);
     }
@@ -15120,8 +15757,8 @@ function parseSkillContent2(content) {
 }
 
 // src/plugins/manager.ts
-import { existsSync as existsSync29, readFileSync as readFileSync19, writeFileSync as writeFileSync17, mkdirSync as mkdirSync18 } from "fs";
-import { join as join28 } from "path";
+import { existsSync as existsSync32, readFileSync as readFileSync21, writeFileSync as writeFileSync19, mkdirSync as mkdirSync20 } from "fs";
+import { join as join31 } from "path";
 var PLUGINS_DIR = ".skillkit/plugins";
 var PLUGINS_CONFIG_FILE = "plugins.json";
 var PluginManager = class {
@@ -15362,22 +15999,22 @@ var PluginManager = class {
   }
   // Private helpers
   loadState() {
-    const statePath = join28(this.projectPath, PLUGINS_DIR, PLUGINS_CONFIG_FILE);
-    if (existsSync29(statePath)) {
+    const statePath = join31(this.projectPath, PLUGINS_DIR, PLUGINS_CONFIG_FILE);
+    if (existsSync32(statePath)) {
       try {
-        return JSON.parse(readFileSync19(statePath, "utf-8"));
+        return JSON.parse(readFileSync21(statePath, "utf-8"));
       } catch {
       }
     }
     return { version: 1, plugins: {} };
   }
   saveState() {
-    const pluginsDir = join28(this.projectPath, PLUGINS_DIR);
-    if (!existsSync29(pluginsDir)) {
-      mkdirSync18(pluginsDir, { recursive: true });
+    const pluginsDir = join31(this.projectPath, PLUGINS_DIR);
+    if (!existsSync32(pluginsDir)) {
+      mkdirSync20(pluginsDir, { recursive: true });
     }
-    const statePath = join28(pluginsDir, PLUGINS_CONFIG_FILE);
-    writeFileSync17(statePath, JSON.stringify(this.state, null, 2), "utf-8");
+    const statePath = join31(pluginsDir, PLUGINS_CONFIG_FILE);
+    writeFileSync19(statePath, JSON.stringify(this.state, null, 2), "utf-8");
   }
   createContext() {
     return {
@@ -15402,15 +16039,15 @@ function createPluginManager(projectPath) {
 }
 
 // src/plugins/loader.ts
-import { existsSync as existsSync30, readFileSync as readFileSync20, readdirSync as readdirSync7, statSync as statSync4 } from "fs";
-import { join as join29, extname, basename as basename13, isAbsolute } from "path";
+import { existsSync as existsSync33, readFileSync as readFileSync22, readdirSync as readdirSync8, statSync as statSync4 } from "fs";
+import { join as join32, extname, basename as basename13, isAbsolute } from "path";
 import { pathToFileURL } from "url";
 var PluginLoader = class {
   /**
    * Load a plugin from a file path
    */
   async loadFromFile(filePath) {
-    if (!existsSync30(filePath)) {
+    if (!existsSync33(filePath)) {
       throw new Error(`Plugin file not found: ${filePath}`);
     }
     const ext = extname(filePath);
@@ -15452,11 +16089,11 @@ var PluginLoader = class {
    * Load a plugin from a JSON definition (for simple plugins)
    */
   loadFromJson(jsonPath) {
-    if (!existsSync30(jsonPath)) {
+    if (!existsSync33(jsonPath)) {
       throw new Error(`Plugin JSON not found: ${jsonPath}`);
     }
     try {
-      const content = readFileSync20(jsonPath, "utf-8");
+      const content = readFileSync22(jsonPath, "utf-8");
       const data = JSON.parse(content);
       if (!data.metadata) {
         throw new Error("Invalid plugin JSON: missing metadata");
@@ -15475,13 +16112,13 @@ var PluginLoader = class {
    * Scan a directory for plugins
    */
   async scanDirectory(dirPath) {
-    if (!existsSync30(dirPath)) {
+    if (!existsSync33(dirPath)) {
       return [];
     }
     const plugins = [];
-    const entries = readdirSync7(dirPath);
+    const entries = readdirSync8(dirPath);
     for (const entry of entries) {
-      const fullPath = join29(dirPath, entry);
+      const fullPath = join32(dirPath, entry);
       let stat;
       try {
         stat = statSync4(fullPath);
@@ -15489,11 +16126,11 @@ var PluginLoader = class {
         continue;
       }
       if (stat.isDirectory()) {
-        const pkgPath = join29(fullPath, "package.json");
-        const pluginPath = join29(fullPath, "plugin.json");
-        if (existsSync30(pkgPath)) {
+        const pkgPath = join32(fullPath, "package.json");
+        const pluginPath = join32(fullPath, "plugin.json");
+        if (existsSync33(pkgPath)) {
           try {
-            const pkg = JSON.parse(readFileSync20(pkgPath, "utf-8"));
+            const pkg = JSON.parse(readFileSync22(pkgPath, "utf-8"));
             if ((pkg.skillkitPlugin || pkg.keywords?.includes("skillkit-plugin")) && pkg.name && typeof pkg.name === "string" && pkg.version && typeof pkg.version === "string") {
               plugins.push({
                 name: pkg.name,
@@ -15505,9 +16142,9 @@ var PluginLoader = class {
             }
           } catch {
           }
-        } else if (existsSync30(pluginPath)) {
+        } else if (existsSync33(pluginPath)) {
           try {
-            const data = JSON.parse(readFileSync20(pluginPath, "utf-8"));
+            const data = JSON.parse(readFileSync22(pluginPath, "utf-8"));
             if (data.metadata && data.metadata.name && typeof data.metadata.name === "string" && data.metadata.version && typeof data.metadata.version === "string") {
               plugins.push(data.metadata);
             }
@@ -15595,12 +16232,12 @@ async function loadPlugin(source) {
 async function loadPluginsFromDirectory(dirPath) {
   const loader = new PluginLoader();
   const plugins = [];
-  if (!existsSync30(dirPath)) {
+  if (!existsSync33(dirPath)) {
     return plugins;
   }
-  const entries = readdirSync7(dirPath);
+  const entries = readdirSync8(dirPath);
   for (const entry of entries) {
-    const fullPath = join29(dirPath, entry);
+    const fullPath = join32(dirPath, entry);
     let stat;
     try {
       stat = statSync4(fullPath);
@@ -15609,20 +16246,20 @@ async function loadPluginsFromDirectory(dirPath) {
     }
     try {
       if (stat.isDirectory()) {
-        const indexMjsPath = join29(fullPath, "index.mjs");
-        const indexPath = join29(fullPath, "index.js");
-        const mainMjsPath = join29(fullPath, "plugin.mjs");
-        const mainPath = join29(fullPath, "plugin.js");
-        const jsonPath = join29(fullPath, "plugin.json");
-        if (existsSync30(indexMjsPath)) {
+        const indexMjsPath = join32(fullPath, "index.mjs");
+        const indexPath = join32(fullPath, "index.js");
+        const mainMjsPath = join32(fullPath, "plugin.mjs");
+        const mainPath = join32(fullPath, "plugin.js");
+        const jsonPath = join32(fullPath, "plugin.json");
+        if (existsSync33(indexMjsPath)) {
           plugins.push(await loader.loadFromFile(indexMjsPath));
-        } else if (existsSync30(indexPath)) {
+        } else if (existsSync33(indexPath)) {
           plugins.push(await loader.loadFromFile(indexPath));
-        } else if (existsSync30(mainMjsPath)) {
+        } else if (existsSync33(mainMjsPath)) {
           plugins.push(await loader.loadFromFile(mainMjsPath));
-        } else if (existsSync30(mainPath)) {
+        } else if (existsSync33(mainPath)) {
           plugins.push(await loader.loadFromFile(mainPath));
-        } else if (existsSync30(jsonPath)) {
+        } else if (existsSync33(jsonPath)) {
           plugins.push(loader.loadFromJson(jsonPath));
         }
       } else if (stat.isFile()) {
@@ -15641,17 +16278,17 @@ async function loadPluginsFromDirectory(dirPath) {
 }
 
 // src/methodology/manager.ts
-import { existsSync as existsSync33, readFileSync as readFileSync23, writeFileSync as writeFileSync18, mkdirSync as mkdirSync19 } from "fs";
-import { join as join32, dirname as dirname11 } from "path";
+import { existsSync as existsSync36, readFileSync as readFileSync25, writeFileSync as writeFileSync20, mkdirSync as mkdirSync21 } from "fs";
+import { join as join35, dirname as dirname11 } from "path";
 
 // src/methodology/loader.ts
-import { existsSync as existsSync32, readFileSync as readFileSync22, readdirSync as readdirSync9, statSync as statSync6 } from "fs";
-import { join as join31, dirname as dirname10 } from "path";
+import { existsSync as existsSync35, readFileSync as readFileSync24, readdirSync as readdirSync10, statSync as statSync6 } from "fs";
+import { join as join34, dirname as dirname10 } from "path";
 import { fileURLToPath } from "url";
 
 // src/methodology/validator.ts
-import { existsSync as existsSync31, readFileSync as readFileSync21, readdirSync as readdirSync8, statSync as statSync5 } from "fs";
-import { join as join30 } from "path";
+import { existsSync as existsSync34, readFileSync as readFileSync23, readdirSync as readdirSync9, statSync as statSync5 } from "fs";
+import { join as join33 } from "path";
 function validatePackManifest(pack) {
   const errors = [];
   const warnings = [];
@@ -15801,15 +16438,15 @@ function validateSkillContent(content) {
 function validatePackDirectory(packPath) {
   const errors = [];
   const warnings = [];
-  if (!existsSync31(packPath)) {
+  if (!existsSync34(packPath)) {
     errors.push({
       code: "DIR_NOT_FOUND",
       message: `Pack directory not found: ${packPath}`
     });
     return { valid: false, errors, warnings };
   }
-  const manifestPath = join30(packPath, "pack.json");
-  if (!existsSync31(manifestPath)) {
+  const manifestPath = join33(packPath, "pack.json");
+  if (!existsSync34(manifestPath)) {
     errors.push({
       code: "MANIFEST_NOT_FOUND",
       message: "Pack must have a pack.json manifest",
@@ -15819,7 +16456,7 @@ function validatePackDirectory(packPath) {
   }
   let manifest;
   try {
-    const raw = readFileSync21(manifestPath, "utf-8");
+    const raw = readFileSync23(manifestPath, "utf-8");
     manifest = JSON.parse(raw);
     const manifestResult = validatePackManifest(manifest);
     errors.push(...manifestResult.errors);
@@ -15834,8 +16471,8 @@ function validatePackDirectory(packPath) {
   }
   if (manifest.skills) {
     for (const skillName of manifest.skills) {
-      const skillDir = join30(packPath, skillName);
-      if (!existsSync31(skillDir)) {
+      const skillDir = join33(packPath, skillName);
+      if (!existsSync34(skillDir)) {
         errors.push({
           code: "SKILL_DIR_NOT_FOUND",
           message: `Skill directory not found: ${skillName}`,
@@ -15851,8 +16488,8 @@ function validatePackDirectory(packPath) {
         });
         continue;
       }
-      const skillFile = join30(skillDir, "SKILL.md");
-      if (!existsSync31(skillFile)) {
+      const skillFile = join33(skillDir, "SKILL.md");
+      if (!existsSync34(skillFile)) {
         errors.push({
           code: "SKILL_FILE_NOT_FOUND",
           message: `Skill must have a SKILL.md file: ${skillName}`,
@@ -15860,7 +16497,7 @@ function validatePackDirectory(packPath) {
         });
         continue;
       }
-      const skillContent = readFileSync21(skillFile, "utf-8");
+      const skillContent = readFileSync23(skillFile, "utf-8");
       const skillResult = validateSkillContent(skillContent);
       for (const err of skillResult.errors) {
         errors.push({
@@ -15884,15 +16521,15 @@ function validatePackDirectory(packPath) {
 }
 function validateBuiltinPacks(packsDir) {
   const results = /* @__PURE__ */ new Map();
-  if (!existsSync31(packsDir)) {
+  if (!existsSync34(packsDir)) {
     return results;
   }
-  const packDirs = readdirSync8(packsDir).filter((name) => {
-    const packPath = join30(packsDir, name);
+  const packDirs = readdirSync9(packsDir).filter((name) => {
+    const packPath = join33(packsDir, name);
     return statSync5(packPath).isDirectory();
   });
   for (const packName of packDirs) {
-    const packPath = join30(packsDir, packName);
+    const packPath = join33(packsDir, packName);
     results.set(packName, validatePackDirectory(packPath));
   }
   return results;
@@ -15951,7 +16588,7 @@ function extractSkillMetadata(content) {
 // src/methodology/loader.ts
 var __filename = fileURLToPath(import.meta.url);
 var __dirname = dirname10(__filename);
-var BUILTIN_PACKS_DIR = join31(__dirname, "packs");
+var BUILTIN_PACKS_DIR = join34(__dirname, "packs");
 var MethodologyLoader = class {
   packsDir;
   loadedPacks = /* @__PURE__ */ new Map();
@@ -15964,11 +16601,11 @@ var MethodologyLoader = class {
    */
   async loadAllPacks() {
     const packs = [];
-    if (!existsSync32(this.packsDir)) {
+    if (!existsSync35(this.packsDir)) {
       return packs;
     }
-    const packDirs = readdirSync9(this.packsDir).filter((name) => {
-      const packPath = join31(this.packsDir, name);
+    const packDirs = readdirSync10(this.packsDir).filter((name) => {
+      const packPath = join34(this.packsDir, name);
       return statSync6(packPath).isDirectory();
     });
     for (const packName of packDirs) {
@@ -15989,9 +16626,9 @@ var MethodologyLoader = class {
     if (this.loadedPacks.has(packName)) {
       return this.loadedPacks.get(packName);
     }
-    const packPath = join31(this.packsDir, packName);
-    const manifestPath = join31(packPath, "pack.json");
-    if (!existsSync32(manifestPath)) {
+    const packPath = join34(this.packsDir, packName);
+    const manifestPath = join34(packPath, "pack.json");
+    if (!existsSync35(manifestPath)) {
       return null;
     }
     const validation = validatePackDirectory(packPath);
@@ -16001,7 +16638,7 @@ var MethodologyLoader = class {
       );
     }
     const manifest = JSON.parse(
-      readFileSync22(manifestPath, "utf-8")
+      readFileSync24(manifestPath, "utf-8")
     );
     this.loadedPacks.set(packName, manifest);
     return manifest;
@@ -16031,11 +16668,11 @@ var MethodologyLoader = class {
     if (this.loadedSkills.has(skillId)) {
       return this.loadedSkills.get(skillId);
     }
-    const skillPath = join31(this.packsDir, packName, skillName, "SKILL.md");
-    if (!existsSync32(skillPath)) {
+    const skillPath = join34(this.packsDir, packName, skillName, "SKILL.md");
+    if (!existsSync35(skillPath)) {
       return null;
     }
-    const content = readFileSync22(skillPath, "utf-8");
+    const content = readFileSync24(skillPath, "utf-8");
     const rawMetadata = extractSkillMetadata(content);
     const metadata = {
       triggers: rawMetadata.triggers,
@@ -16114,9 +16751,9 @@ var MethodologyLoader = class {
    * Check if a pack exists
    */
   packExists(packName) {
-    const packPath = join31(this.packsDir, packName);
-    const manifestPath = join31(packPath, "pack.json");
-    return existsSync32(manifestPath);
+    const packPath = join34(this.packsDir, packName);
+    const manifestPath = join34(packPath, "pack.json");
+    return existsSync35(manifestPath);
   }
   /**
    * Clear cache
@@ -16482,10 +17119,10 @@ var MethodologyManager = class {
   }
   // Private helpers
   loadState() {
-    const statePath = join32(this.projectPath, METHODOLOGY_STATE_FILE);
-    if (existsSync33(statePath)) {
+    const statePath = join35(this.projectPath, METHODOLOGY_STATE_FILE);
+    if (existsSync36(statePath)) {
       try {
-        return JSON.parse(readFileSync23(statePath, "utf-8"));
+        return JSON.parse(readFileSync25(statePath, "utf-8"));
       } catch {
       }
     }
@@ -16496,21 +17133,21 @@ var MethodologyManager = class {
     };
   }
   saveState() {
-    const statePath = join32(this.projectPath, METHODOLOGY_STATE_FILE);
+    const statePath = join35(this.projectPath, METHODOLOGY_STATE_FILE);
     const dir = dirname11(statePath);
-    if (!existsSync33(dir)) {
-      mkdirSync19(dir, { recursive: true });
+    if (!existsSync36(dir)) {
+      mkdirSync21(dir, { recursive: true });
     }
-    writeFileSync18(statePath, JSON.stringify(this.state, null, 2), "utf-8");
+    writeFileSync20(statePath, JSON.stringify(this.state, null, 2), "utf-8");
   }
   async installSkillLocally(skill) {
-    const skillsDir = join32(this.projectPath, ".skillkit", "methodology", "skills");
-    const skillDir = join32(skillsDir, skill.pack, skill.id.split("/")[1]);
-    if (!existsSync33(skillDir)) {
-      mkdirSync19(skillDir, { recursive: true });
+    const skillsDir = join35(this.projectPath, ".skillkit", "methodology", "skills");
+    const skillDir = join35(skillsDir, skill.pack, skill.id.split("/")[1]);
+    if (!existsSync36(skillDir)) {
+      mkdirSync21(skillDir, { recursive: true });
     }
-    const targetPath = join32(skillDir, "SKILL.md");
-    writeFileSync18(targetPath, skill.content, "utf-8");
+    const targetPath = join35(skillDir, "SKILL.md");
+    writeFileSync20(targetPath, skill.content, "utf-8");
   }
   async removeSkillLocally(_skillId) {
   }
@@ -16538,9 +17175,9 @@ var MethodologyManager = class {
     if (!agentDir) {
       throw new Error(`Unknown agent: ${agent}`);
     }
-    const skillsDir = join32(this.projectPath, agentDir);
-    if (!existsSync33(skillsDir)) {
-      mkdirSync19(skillsDir, { recursive: true });
+    const skillsDir = join35(this.projectPath, agentDir);
+    if (!existsSync36(skillsDir)) {
+      mkdirSync21(skillsDir, { recursive: true });
     }
     const skillName = skillId.split("/")[1];
     let filename;
@@ -16551,8 +17188,8 @@ var MethodologyManager = class {
     } else {
       filename = `${skillName}.md`;
     }
-    const targetPath = join32(skillsDir, filename);
-    writeFileSync18(targetPath, content, "utf-8");
+    const targetPath = join35(skillsDir, filename);
+    writeFileSync20(targetPath, content, "utf-8");
   }
   detectAgents() {
     const agents = [];
@@ -16575,7 +17212,7 @@ var MethodologyManager = class {
       ["windsurf", ".windsurf"]
     ];
     for (const [agent, dir] of agentDirs) {
-      if (existsSync33(join32(this.projectPath, dir))) {
+      if (existsSync36(join35(this.projectPath, dir))) {
         agents.push(agent);
       }
     }
@@ -16588,8 +17225,8 @@ function createMethodologyManager(options) {
 }
 
 // src/hooks/manager.ts
-import { existsSync as existsSync34, readFileSync as readFileSync24, writeFileSync as writeFileSync19, mkdirSync as mkdirSync20 } from "fs";
-import { join as join33, dirname as dirname12 } from "path";
+import { existsSync as existsSync37, readFileSync as readFileSync26, writeFileSync as writeFileSync21, mkdirSync as mkdirSync22 } from "fs";
+import { join as join36, dirname as dirname12 } from "path";
 import { randomUUID as randomUUID11 } from "crypto";
 import { minimatch } from "minimatch";
 var DEFAULT_CONFIG_PATH = ".skillkit/hooks.json";
@@ -16600,7 +17237,7 @@ var HookManager = class {
   constructor(options) {
     this.options = {
       projectPath: options.projectPath,
-      configPath: options.configPath || join33(options.projectPath, DEFAULT_CONFIG_PATH),
+      configPath: options.configPath || join36(options.projectPath, DEFAULT_CONFIG_PATH),
       autoLoad: options.autoLoad ?? true,
       defaultInjectionMode: options.defaultInjectionMode || "reference"
     };
@@ -16740,11 +17377,11 @@ var HookManager = class {
    * Load hooks from config file
    */
   load() {
-    if (!existsSync34(this.options.configPath)) {
+    if (!existsSync37(this.options.configPath)) {
       return;
     }
     try {
-      const content = readFileSync24(this.options.configPath, "utf-8");
+      const content = readFileSync26(this.options.configPath, "utf-8");
       const config = JSON.parse(content);
       this.hooks.clear();
       for (const hook of config.hooks) {
@@ -16772,10 +17409,10 @@ var HookManager = class {
       }
     };
     const dir = dirname12(this.options.configPath);
-    if (!existsSync34(dir)) {
-      mkdirSync20(dir, { recursive: true });
+    if (!existsSync37(dir)) {
+      mkdirSync22(dir, { recursive: true });
     }
-    writeFileSync19(this.options.configPath, JSON.stringify(config, null, 2));
+    writeFileSync21(this.options.configPath, JSON.stringify(config, null, 2));
   }
   /**
    * Generate agent-specific hook configuration
@@ -17017,7 +17654,7 @@ function createHookManager(options) {
 
 // src/hooks/triggers.ts
 import { watch } from "fs";
-import { join as join34, relative as relative2 } from "path";
+import { join as join37, relative as relative2 } from "path";
 function debounce(fn, delay) {
   let timeoutId = null;
   return (...args) => {
@@ -17202,7 +17839,7 @@ var SkillTriggerEngine = class {
         { recursive: true },
         debounce((eventType, filename) => {
           if (!filename) return;
-          const relativePath = relative2(this.options.projectPath, join34(this.options.projectPath, filename));
+          const relativePath = relative2(this.options.projectPath, join37(this.options.projectPath, filename));
           if (this.shouldIgnore(relativePath)) return;
           if (eventType === "rename") {
             this.triggerFileCreate(relativePath);
@@ -19645,15 +20282,194 @@ var shellExecutor = async (step, _task, _plan) => {
         error: `Expected output "${step.expectedOutput}" not found`
       };
     }
-    return { success: true, output };
-  } catch (error) {
-    return {
-      success: false,
-      output: "",
-      error: error.message
+    return { success: true, output };
+  } catch (error) {
+    return {
+      success: false,
+      output: "",
+      error: error.message
+    };
+  }
+};
+
+// src/plan/issue-planner.ts
+import { execFileSync } from "child_process";
+var LABEL_TAG_MAP = {
+  bug: "fix",
+  fix: "fix",
+  enhancement: "feature",
+  feature: "feature",
+  documentation: "docs",
+  docs: "docs",
+  refactor: "refactor",
+  refactoring: "refactor",
+  test: "test",
+  testing: "test",
+  security: "security",
+  performance: "performance",
+  "good first issue": "beginner",
+  chore: "chore",
+  maintenance: "chore"
+};
+var FILE_PATH_REGEX = /`([a-zA-Z0-9_./\-]+\.[a-zA-Z0-9]+)`/g;
+var IssuePlanner = class {
+  parseIssueRef(ref) {
+    const urlMatch = ref.match(
+      /github\.com\/([^/]+)\/([^/]+)\/issues\/(\d+)/
+    );
+    if (urlMatch) {
+      return {
+        owner: urlMatch[1],
+        repo: urlMatch[2],
+        number: parseInt(urlMatch[3], 10)
+      };
+    }
+    const fullMatch = ref.match(/^([^/]+)\/([^#]+)#(\d+)$/);
+    if (fullMatch) {
+      return {
+        owner: fullMatch[1],
+        repo: fullMatch[2],
+        number: parseInt(fullMatch[3], 10)
+      };
+    }
+    const shortMatch = ref.match(/^#?(\d+)$/);
+    if (shortMatch) {
+      return { number: parseInt(shortMatch[1], 10) };
+    }
+    throw new Error(
+      `Invalid issue reference: "${ref}". Use #123, owner/repo#123, or a GitHub URL.`
+    );
+  }
+  fetchIssue(ref) {
+    const parsed = this.parseIssueRef(ref);
+    const args = [
+      "issue",
+      "view",
+      String(parsed.number),
+      "--json",
+      "number,title,body,labels,assignees,url,state"
+    ];
+    if (parsed.owner && parsed.repo) {
+      args.push("--repo", `${parsed.owner}/${parsed.repo}`);
+    }
+    const result = execFileSync("gh", args, {
+      encoding: "utf-8",
+      timeout: 15e3
+    });
+    let data;
+    try {
+      data = JSON.parse(result);
+    } catch {
+      throw new Error(`Failed to parse GitHub CLI response for issue ${parsed.number}`);
+    }
+    return {
+      number: data.number,
+      title: data.title,
+      body: data.body || "",
+      labels: (data.labels || []).map((l) => l.name),
+      assignees: (data.assignees || []).map((a) => a.login),
+      url: data.url,
+      state: data.state
+    };
+  }
+  extractTasksFromBody(body) {
+    const tasks = [];
+    const lines = body.split("\n");
+    for (const line of lines) {
+      const match = line.match(/^[\s]*-\s*\[([ xX])\]\s+(.+)$/);
+      if (match) {
+        tasks.push({
+          name: match[2].trim(),
+          checked: match[1] !== " "
+        });
+      }
+    }
+    return tasks;
+  }
+  extractFileMentions(text) {
+    const files = /* @__PURE__ */ new Set();
+    let match;
+    const regex = new RegExp(FILE_PATH_REGEX.source, "g");
+    while ((match = regex.exec(text)) !== null) {
+      const path4 = match[1];
+      if (path4.includes("/") || path4.includes(".")) {
+        files.add(path4);
+      }
+    }
+    return [...files];
+  }
+  inferLabelsToTags(labels) {
+    const tags = [];
+    for (const label of labels) {
+      const tag = LABEL_TAG_MAP[label.toLowerCase()];
+      if (tag && !tags.includes(tag)) {
+        tags.push(tag);
+      }
+    }
+    return tags;
+  }
+  generatePlan(issue, options) {
+    const agent = options?.agent || "claude-code";
+    const includeTests = options?.includeTests !== false;
+    const bodyFirstParagraph = issue.body.split("\n\n")[0]?.trim() || issue.title;
+    const generator = new PlanGenerator({
+      includeTests,
+      includeCommits: true,
+      techStack: options?.techStack
+    });
+    const plan = generator.createPlan(
+      `Issue #${issue.number}: ${issue.title}`,
+      bodyFirstParagraph
+    );
+    plan.tags = this.inferLabelsToTags(issue.labels);
+    const checklist = this.extractTasksFromBody(issue.body);
+    const allFileMentions = this.extractFileMentions(issue.body);
+    if (checklist.length > 0) {
+      for (const item of checklist) {
+        const taskFiles = this.extractFileMentions(item.name);
+        const files = {};
+        if (taskFiles.length > 0) {
+          files.modify = taskFiles;
+        }
+        const task = generator.addTask(plan, item.name, {
+          files,
+          tags: item.checked ? ["done"] : void 0,
+          steps: [
+            { type: "implement", description: item.name },
+            ...includeTests ? [{ type: "test", description: `Write tests for ${item.name}` }] : []
+          ]
+        });
+        if (item.checked) {
+          task.status = "completed";
+        }
+      }
+    } else {
+      const files = {};
+      if (allFileMentions.length > 0) {
+        files.modify = allFileMentions;
+      }
+      generator.addTask(plan, issue.title, {
+        description: bodyFirstParagraph,
+        files,
+        steps: [
+          { type: "implement", description: issue.title },
+          ...includeTests ? [{ type: "test", description: `Write tests for ${issue.title}` }] : []
+        ]
+      });
+    }
+    plan.metadata = {
+      issueNumber: issue.number,
+      issueUrl: issue.url,
+      issueLabels: issue.labels,
+      agent,
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
+    return plan;
   }
 };
+function createIssuePlanner() {
+  return new IssuePlanner();
+}
 
 // src/commands/registry.ts
 var CommandRegistry = class {
@@ -22505,8 +23321,8 @@ Source: ${doc.url}`;
 };
 
 // src/ai/context/codebase-source.ts
-import { existsSync as existsSync35, readdirSync as readdirSync10, readFileSync as readFileSync25, statSync as statSync7 } from "fs";
-import { join as join35, extname as extname2, basename as basename14 } from "path";
+import { existsSync as existsSync38, readdirSync as readdirSync11, readFileSync as readFileSync27, statSync as statSync7 } from "fs";
+import { join as join38, extname as extname2, basename as basename14 } from "path";
 var CodebaseSource = class {
   name = "codebase";
   displayName = "Local Codebase";
@@ -22534,7 +23350,7 @@ var CodebaseSource = class {
     return chunks;
   }
   async isAvailable() {
-    return existsSync35(this.projectPath);
+    return existsSync38(this.projectPath);
   }
   async analyzeCodebase(basePath, query) {
     const patterns = [];
@@ -22551,10 +23367,10 @@ var CodebaseSource = class {
   }
   async detectFrameworks(basePath) {
     const patterns = [];
-    const packageJsonPath = join35(basePath, "package.json");
-    if (existsSync35(packageJsonPath)) {
+    const packageJsonPath = join38(basePath, "package.json");
+    if (existsSync38(packageJsonPath)) {
       try {
-        const content = readFileSync25(packageJsonPath, "utf-8");
+        const content = readFileSync27(packageJsonPath, "utf-8");
         const pkg = JSON.parse(content);
         const deps = { ...pkg.dependencies, ...pkg.devDependencies };
         const frameworks = [
@@ -22581,8 +23397,8 @@ var CodebaseSource = class {
       } catch {
       }
     }
-    const pyprojectPath = join35(basePath, "pyproject.toml");
-    if (existsSync35(pyprojectPath)) {
+    const pyprojectPath = join38(basePath, "pyproject.toml");
+    if (existsSync38(pyprojectPath)) {
       patterns.push({
         type: "framework",
         name: "Python",
@@ -22591,8 +23407,8 @@ var CodebaseSource = class {
         relevance: 0.7
       });
     }
-    const cargoPath = join35(basePath, "Cargo.toml");
-    if (existsSync35(cargoPath)) {
+    const cargoPath = join38(basePath, "Cargo.toml");
+    if (existsSync38(cargoPath)) {
       patterns.push({
         type: "framework",
         name: "Rust",
@@ -22601,8 +23417,8 @@ var CodebaseSource = class {
         relevance: 0.7
       });
     }
-    const goModPath = join35(basePath, "go.mod");
-    if (existsSync35(goModPath)) {
+    const goModPath = join38(basePath, "go.mod");
+    if (existsSync38(goModPath)) {
       patterns.push({
         type: "framework",
         name: "Go",
@@ -22615,10 +23431,10 @@ var CodebaseSource = class {
   }
   async detectTestingSetup(basePath) {
     const patterns = [];
-    const packageJsonPath = join35(basePath, "package.json");
-    if (existsSync35(packageJsonPath)) {
+    const packageJsonPath = join38(basePath, "package.json");
+    if (existsSync38(packageJsonPath)) {
       try {
-        const content = readFileSync25(packageJsonPath, "utf-8");
+        const content = readFileSync27(packageJsonPath, "utf-8");
         const pkg = JSON.parse(content);
         const deps = { ...pkg.dependencies, ...pkg.devDependencies };
         const testFrameworks = [
@@ -22643,10 +23459,10 @@ var CodebaseSource = class {
       } catch {
       }
     }
-    const vitestConfig = join35(basePath, "vitest.config.ts");
-    if (existsSync35(vitestConfig)) {
+    const vitestConfig = join38(basePath, "vitest.config.ts");
+    if (existsSync38(vitestConfig)) {
       try {
-        const content = readFileSync25(vitestConfig, "utf-8");
+        const content = readFileSync27(vitestConfig, "utf-8");
         patterns.push({
           type: "testing",
           name: "Vitest Config",
@@ -22657,10 +23473,10 @@ var CodebaseSource = class {
       } catch {
       }
     }
-    const jestConfig = join35(basePath, "jest.config.js");
-    if (existsSync35(jestConfig)) {
+    const jestConfig = join38(basePath, "jest.config.js");
+    if (existsSync38(jestConfig)) {
       try {
-        const content = readFileSync25(jestConfig, "utf-8");
+        const content = readFileSync27(jestConfig, "utf-8");
         patterns.push({
           type: "testing",
           name: "Jest Config",
@@ -22684,10 +23500,10 @@ var CodebaseSource = class {
       { file: "tailwind.config.ts", name: "Tailwind" }
     ];
     for (const { file, name } of configFiles) {
-      const filePath = join35(basePath, file);
-      if (existsSync35(filePath)) {
+      const filePath = join38(basePath, file);
+      if (existsSync38(filePath)) {
         try {
-          const content = readFileSync25(filePath, "utf-8");
+          const content = readFileSync27(filePath, "utf-8");
           patterns.push({
             type: "config",
             name: `${name} Config`,
@@ -22706,12 +23522,12 @@ var CodebaseSource = class {
     const keywords = query.toLowerCase().split(/\s+/);
     const searchDirs = ["src", "lib", "app", "pages", "components"];
     for (const dir of searchDirs) {
-      const dirPath = join35(basePath, dir);
-      if (existsSync35(dirPath)) {
+      const dirPath = join38(basePath, dir);
+      if (existsSync38(dirPath)) {
         const files = this.findFilesRecursive(dirPath, [".ts", ".tsx", ".js", ".jsx", ".py", ".go", ".rs"]);
         for (const file of files.slice(0, 20)) {
           try {
-            const content = readFileSync25(file, "utf-8");
+            const content = readFileSync27(file, "utf-8");
             const fileName = basename14(file).toLowerCase();
             const relevance = this.calculateRelevance(fileName, content, keywords);
             if (relevance > 0.3) {
@@ -22733,12 +23549,12 @@ var CodebaseSource = class {
   findFilesRecursive(dir, extensions) {
     const files = [];
     try {
-      const entries = readdirSync10(dir);
+      const entries = readdirSync11(dir);
       for (const entry of entries) {
         if (entry.startsWith(".") || entry === "node_modules" || entry === "dist") {
           continue;
         }
-        const fullPath = join35(dir, entry);
+        const fullPath = join38(dir, entry);
         try {
           const stat = statSync7(fullPath);
           if (stat.isDirectory()) {
@@ -22984,8 +23800,8 @@ This existing skill can be composed with or referenced for patterns.`;
 };
 
 // src/ai/context/memory-source.ts
-import { existsSync as existsSync36, readFileSync as readFileSync26 } from "fs";
-import { join as join36 } from "path";
+import { existsSync as existsSync39, readFileSync as readFileSync28 } from "fs";
+import { join as join39 } from "path";
 var MemorySource = class {
   name = "memory";
   displayName = "Memory & Learnings";
@@ -23029,8 +23845,8 @@ ${entry.pattern}`,
   }
   async isAvailable() {
     const claudeMdPath = this.findClaudeMd(this.projectPath);
-    const memoryPath = join36(this.projectPath, ".skillkit", "memory", "observations.yaml");
-    return existsSync36(claudeMdPath) || existsSync36(memoryPath);
+    const memoryPath = join39(this.projectPath, ".skillkit", "memory", "observations.yaml");
+    return existsSync39(claudeMdPath) || existsSync39(memoryPath);
   }
   async getMemoryPatterns(keywords) {
     const patterns = [];
@@ -23047,11 +23863,11 @@ ${entry.pattern}`,
   }
   async getLearnedEntries(basePath) {
     const claudeMdPath = this.findClaudeMd(basePath);
-    if (!existsSync36(claudeMdPath)) {
+    if (!existsSync39(claudeMdPath)) {
       return [];
     }
     try {
-      const content = readFileSync26(claudeMdPath, "utf-8");
+      const content = readFileSync28(claudeMdPath, "utf-8");
       return this.parseLearnedSection(content);
     } catch {
       return [];
@@ -23137,18 +23953,18 @@ ${obs.content}
 Relevance: ${obs.relevance}%`;
   }
   findClaudeMd(basePath) {
-    const localPath = join36(basePath, "CLAUDE.md");
-    if (existsSync36(localPath)) {
+    const localPath = join39(basePath, "CLAUDE.md");
+    if (existsSync39(localPath)) {
       return localPath;
     }
     const homeDir = process.env.HOME || process.env.USERPROFILE || "";
-    const globalPath = join36(homeDir, ".claude", "CLAUDE.md");
-    if (existsSync36(globalPath)) {
+    const globalPath = join39(homeDir, ".claude", "CLAUDE.md");
+    if (existsSync39(globalPath)) {
       return globalPath;
     }
     const projectKey = basePath.replace(/[\\/]/g, "-");
-    const projectMemoryPath = join36(homeDir, ".claude", "projects", projectKey, "memory", "MEMORY.md");
-    if (existsSync36(projectMemoryPath)) {
+    const projectMemoryPath = join39(homeDir, ".claude", "projects", projectKey, "memory", "MEMORY.md");
+    if (existsSync39(projectMemoryPath)) {
       return projectMemoryPath;
     }
     return localPath;
@@ -25560,8 +26376,8 @@ var CUSTOM_AGENT_FORMAT_MAP = {
 };
 
 // src/agents/parser.ts
-import { existsSync as existsSync37, readFileSync as readFileSync27, statSync as statSync8 } from "fs";
-import { join as join37, basename as basename15, extname as extname3 } from "path";
+import { existsSync as existsSync40, readFileSync as readFileSync29, statSync as statSync8 } from "fs";
+import { join as join40, basename as basename15, extname as extname3 } from "path";
 import { parse as parseYaml10 } from "yaml";
 function extractAgentFrontmatter(content) {
   const match = content.match(/^---\s*\n([\s\S]*?)\n---/);
@@ -25579,14 +26395,14 @@ function extractAgentContent(content) {
   return withoutFrontmatter.trim();
 }
 function parseAgentFile(filePath, location = "project") {
-  if (!existsSync37(filePath)) {
+  if (!existsSync40(filePath)) {
     return null;
   }
   if (extname3(filePath) !== ".md") {
     return null;
   }
   try {
-    const content = readFileSync27(filePath, "utf-8");
+    const content = readFileSync29(filePath, "utf-8");
     const rawFrontmatter = extractAgentFrontmatter(content);
     const agentContent = extractAgentContent(content);
     if (!rawFrontmatter) {
@@ -25638,16 +26454,16 @@ function parseAgentFile(filePath, location = "project") {
   }
 }
 function parseAgentDir(dirPath, location = "project") {
-  const agentMdPath = join37(dirPath, "AGENT.md");
-  if (existsSync37(agentMdPath)) {
+  const agentMdPath = join40(dirPath, "AGENT.md");
+  if (existsSync40(agentMdPath)) {
     const agent = parseAgentFile(agentMdPath, location);
     if (agent) {
       agent.path = dirPath;
     }
     return agent;
   }
-  const indexMdPath = join37(dirPath, "index.md");
-  if (existsSync37(indexMdPath)) {
+  const indexMdPath = join40(dirPath, "index.md");
+  if (existsSync40(indexMdPath)) {
     const agent = parseAgentFile(indexMdPath, location);
     if (agent) {
       agent.path = dirPath;
@@ -25657,11 +26473,11 @@ function parseAgentDir(dirPath, location = "project") {
   return null;
 }
 function loadAgentMetadata(metadataPath) {
-  if (!existsSync37(metadataPath)) {
+  if (!existsSync40(metadataPath)) {
     return null;
   }
   try {
-    const content = readFileSync27(metadataPath, "utf-8");
+    const content = readFileSync29(metadataPath, "utf-8");
     const data = JSON.parse(content);
     const parsed = AgentMetadata.safeParse(data);
     return parsed.success ? parsed.data : null;
@@ -25762,25 +26578,25 @@ function fromCanonicalAgent(canonical, _targetFormat = "claude-agent") {
   return lines.join("\n");
 }
 function readAgentContent(agentPath) {
-  if (existsSync37(agentPath) && extname3(agentPath) === ".md") {
+  if (existsSync40(agentPath) && extname3(agentPath) === ".md") {
     try {
-      return readFileSync27(agentPath, "utf-8");
+      return readFileSync29(agentPath, "utf-8");
     } catch {
       return null;
     }
   }
-  const agentMdPath = join37(agentPath, "AGENT.md");
-  if (existsSync37(agentMdPath)) {
+  const agentMdPath = join40(agentPath, "AGENT.md");
+  if (existsSync40(agentMdPath)) {
     try {
-      return readFileSync27(agentMdPath, "utf-8");
+      return readFileSync29(agentMdPath, "utf-8");
     } catch {
       return null;
     }
   }
-  const indexMdPath = join37(agentPath, "index.md");
-  if (existsSync37(indexMdPath)) {
+  const indexMdPath = join40(agentPath, "index.md");
+  if (existsSync40(indexMdPath)) {
     try {
-      return readFileSync27(indexMdPath, "utf-8");
+      return readFileSync29(indexMdPath, "utf-8");
     } catch {
       return null;
     }
@@ -25791,17 +26607,17 @@ function validateAgent(agentPath) {
   const errors = [];
   const warnings = [];
   let filePath = agentPath;
-  if (!existsSync37(agentPath)) {
+  if (!existsSync40(agentPath)) {
     errors.push(`Agent file not found: ${agentPath}`);
     return { valid: false, errors, warnings };
   }
   const stats = statSync8(agentPath);
   if (stats.isDirectory()) {
-    const agentMd = join37(agentPath, "AGENT.md");
-    const indexMd = join37(agentPath, "index.md");
-    if (existsSync37(agentMd)) {
+    const agentMd = join40(agentPath, "AGENT.md");
+    const indexMd = join40(agentPath, "index.md");
+    if (existsSync40(agentMd)) {
       filePath = agentMd;
-    } else if (existsSync37(indexMd)) {
+    } else if (existsSync40(indexMd)) {
       filePath = indexMd;
     } else {
       errors.push("Directory must contain AGENT.md or index.md");
@@ -25810,7 +26626,7 @@ function validateAgent(agentPath) {
   }
   let content;
   try {
-    content = readFileSync27(filePath, "utf-8");
+    content = readFileSync29(filePath, "utf-8");
   } catch {
     errors.push(`Cannot read file: ${filePath}`);
     return { valid: false, errors, warnings };
@@ -25847,18 +26663,18 @@ function validateAgent(agentPath) {
 }
 
 // src/agents/discovery.ts
-import { existsSync as existsSync38, readdirSync as readdirSync11, statSync as statSync9 } from "fs";
-import { join as join38, extname as extname4 } from "path";
+import { existsSync as existsSync41, readdirSync as readdirSync12, statSync as statSync9 } from "fs";
+import { join as join41, extname as extname4 } from "path";
 import { homedir as homedir13 } from "os";
 function discoverAgentsInDir(dir, location) {
   const agents = [];
-  if (!existsSync38(dir)) {
+  if (!existsSync41(dir)) {
     return agents;
   }
   try {
-    const entries = readdirSync11(dir, { withFileTypes: true });
+    const entries = readdirSync12(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const entryPath = join38(dir, entry.name);
+      const entryPath = join41(dir, entry.name);
       if (entry.isFile() && extname4(entry.name) === ".md") {
         const agent = parseAgentFile(entryPath, location);
         if (agent) {
@@ -25879,8 +26695,8 @@ function discoverAgents(rootDir) {
   const agents = [];
   const seen = /* @__PURE__ */ new Set();
   for (const searchPath of ALL_AGENT_DISCOVERY_PATHS) {
-    const fullPath = join38(rootDir, searchPath);
-    if (existsSync38(fullPath)) {
+    const fullPath = join41(rootDir, searchPath);
+    if (existsSync41(fullPath)) {
       for (const agent of discoverAgentsInDir(fullPath, "project")) {
         if (!seen.has(agent.name)) {
           seen.add(agent.name);
@@ -25896,8 +26712,8 @@ function discoverAgentsForAgent(rootDir, agentType) {
   const seen = /* @__PURE__ */ new Set();
   const paths = AGENT_DISCOVERY_PATHS[agentType] || [];
   for (const searchPath of paths) {
-    const fullPath = join38(rootDir, searchPath);
-    if (existsSync38(fullPath)) {
+    const fullPath = join41(rootDir, searchPath);
+    if (existsSync41(fullPath)) {
       for (const agent of discoverAgentsInDir(fullPath, "project")) {
         if (!seen.has(agent.name)) {
           seen.add(agent.name);
@@ -25913,12 +26729,12 @@ function discoverGlobalAgents() {
   const seen = /* @__PURE__ */ new Set();
   const home = homedir13();
   const globalPaths = [
-    join38(home, ".claude", "agents"),
-    join38(home, ".skillkit", "agents"),
-    join38(home, ".config", "skillkit", "agents")
+    join41(home, ".claude", "agents"),
+    join41(home, ".skillkit", "agents"),
+    join41(home, ".config", "skillkit", "agents")
   ];
   for (const searchPath of globalPaths) {
-    if (existsSync38(searchPath)) {
+    if (existsSync41(searchPath)) {
       for (const agent of discoverAgentsInDir(searchPath, "global")) {
         if (!seen.has(agent.name)) {
           seen.add(agent.name);
@@ -25933,7 +26749,7 @@ function findAllAgents(searchDirs) {
   const agents = [];
   const seen = /* @__PURE__ */ new Set();
   for (const dir of searchDirs) {
-    if (!existsSync38(dir)) continue;
+    if (!existsSync41(dir)) continue;
     const discovered = discoverAgents(dir);
     for (const agent of discovered) {
       if (!seen.has(agent.name)) {
@@ -25952,33 +26768,33 @@ function findAllAgents(searchDirs) {
 }
 function findAgent(name, searchDirs) {
   for (const dir of searchDirs) {
-    if (!existsSync38(dir)) continue;
+    if (!existsSync41(dir)) continue;
     for (const searchPath of ALL_AGENT_DISCOVERY_PATHS) {
-      const agentsDir = join38(dir, searchPath);
-      if (!existsSync38(agentsDir)) continue;
-      const agentFile = join38(agentsDir, `${name}.md`);
-      if (existsSync38(agentFile)) {
+      const agentsDir = join41(dir, searchPath);
+      if (!existsSync41(agentsDir)) continue;
+      const agentFile = join41(agentsDir, `${name}.md`);
+      if (existsSync41(agentFile)) {
         return parseAgentFile(agentFile, "project");
       }
-      const agentDir = join38(agentsDir, name);
-      if (existsSync38(agentDir) && statSync9(agentDir).isDirectory()) {
+      const agentDir = join41(agentsDir, name);
+      if (existsSync41(agentDir) && statSync9(agentDir).isDirectory()) {
         return parseAgentDir(agentDir, "project");
       }
     }
   }
   const home = homedir13();
   const globalPaths = [
-    join38(home, ".claude", "agents"),
-    join38(home, ".skillkit", "agents")
+    join41(home, ".claude", "agents"),
+    join41(home, ".skillkit", "agents")
   ];
   for (const agentsDir of globalPaths) {
-    if (!existsSync38(agentsDir)) continue;
-    const agentFile = join38(agentsDir, `${name}.md`);
-    if (existsSync38(agentFile)) {
+    if (!existsSync41(agentsDir)) continue;
+    const agentFile = join41(agentsDir, `${name}.md`);
+    if (existsSync41(agentFile)) {
       return parseAgentFile(agentFile, "global");
     }
-    const agentDir = join38(agentsDir, name);
-    if (existsSync38(agentDir) && statSync9(agentDir).isDirectory()) {
+    const agentDir = join41(agentsDir, name);
+    if (existsSync41(agentDir) && statSync9(agentDir).isDirectory()) {
       return parseAgentDir(agentDir, "global");
     }
   }
@@ -25987,9 +26803,9 @@ function findAgent(name, searchDirs) {
 function getAgentsDirectory(rootDir, agentType) {
   const paths = AGENT_DISCOVERY_PATHS[agentType];
   if (paths && paths.length > 0) {
-    return join38(rootDir, paths[0]);
+    return join41(rootDir, paths[0]);
   }
-  return join38(rootDir, "agents");
+  return join41(rootDir, "agents");
 }
 function agentExists(name, searchDirs) {
   return findAgent(name, searchDirs) !== null;
@@ -26007,14 +26823,14 @@ function getAgentStats(searchDirs) {
 function discoverAgentsRecursive(rootDir, location = "project") {
   const agents = [];
   const seen = /* @__PURE__ */ new Set();
-  if (!existsSync38(rootDir)) {
+  if (!existsSync41(rootDir)) {
     return agents;
   }
   function scanDirectory(dir) {
     try {
-      const entries = readdirSync11(dir, { withFileTypes: true });
+      const entries = readdirSync12(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const entryPath = join38(dir, entry.name);
+        const entryPath = join41(dir, entry.name);
         if (entry.isFile() && extname4(entry.name) === ".md") {
           const agent = parseAgentFile(entryPath, location);
           if (agent && !seen.has(agent.name)) {
@@ -26041,7 +26857,7 @@ function discoverAgentsRecursive(rootDir, location = "project") {
   return agents;
 }
 function discoverAgentsFromPath(sourcePath, recursive = false, location = "project") {
-  if (!existsSync38(sourcePath)) {
+  if (!existsSync41(sourcePath)) {
     return [];
   }
   const stats = statSync9(sourcePath);
@@ -26062,9 +26878,9 @@ function discoverAgentsFromPath(sourcePath, recursive = false, location = "proje
     }
     const agents = [];
     try {
-      const entries = readdirSync11(sourcePath, { withFileTypes: true });
+      const entries = readdirSync12(sourcePath, { withFileTypes: true });
       for (const entry of entries) {
-        const entryPath = join38(sourcePath, entry.name);
+        const entryPath = join41(sourcePath, entry.name);
         if (entry.isFile() && extname4(entry.name) === ".md") {
           const a = parseAgentFile(entryPath, location);
           if (a) agents.push(a);
@@ -26081,7 +26897,7 @@ function discoverAgentsFromPath(sourcePath, recursive = false, location = "proje
 }
 
 // src/agents/translator.ts
-import { join as join39 } from "path";
+import { join as join42 } from "path";
 function translateAgent(agent, targetAgent, options) {
   const canonical = toCanonicalAgent(agent);
   return translateCanonicalAgent(canonical, targetAgent, options);
@@ -26302,9 +27118,9 @@ function getAgentFilename(agentName, targetAgent) {
 function getAgentTargetDirectory(rootDir, targetAgent) {
   const paths = AGENT_DISCOVERY_PATHS[targetAgent];
   if (paths && paths.length > 0) {
-    return join39(rootDir, paths[0]);
+    return join42(rootDir, paths[0]);
   }
-  return join39(rootDir, "agents");
+  return join42(rootDir, "agents");
 }
 function escapeYamlString(str) {
   if (/[:\{\}\[\],&*#?|\-<>=!%@`]/.test(str) || str.includes("\n")) {
@@ -26491,8 +27307,8 @@ function loadAndConvertSkill(skill, options) {
 }
 
 // src/skill-translator.ts
-import { readFileSync as readFileSync28, existsSync as existsSync39, writeFileSync as writeFileSync20, mkdirSync as mkdirSync21 } from "fs";
-import { join as join40, basename as basename16, dirname as dirname13, resolve as resolve5, relative as relative3, isAbsolute as isAbsolute2 } from "path";
+import { readFileSync as readFileSync30, existsSync as existsSync42, writeFileSync as writeFileSync22, mkdirSync as mkdirSync23 } from "fs";
+import { join as join43, basename as basename16, dirname as dirname13, resolve as resolve5, relative as relative3, isAbsolute as isAbsolute2 } from "path";
 import { parse as parseYaml11, stringify as stringifyYaml8 } from "yaml";
 var AGENT_SKILL_FORMATS = Object.fromEntries(
   Object.entries(AGENT_CONFIG).map(([agent, config]) => [
@@ -26501,12 +27317,12 @@ var AGENT_SKILL_FORMATS = Object.fromEntries(
   ])
 );
 function parseSkillToCanonical(skillPath, sourceAgent) {
-  const skillMdPath = skillPath.endsWith("SKILL.md") ? skillPath : join40(skillPath, "SKILL.md");
-  if (!existsSync39(skillMdPath)) {
+  const skillMdPath = skillPath.endsWith("SKILL.md") ? skillPath : join43(skillPath, "SKILL.md");
+  if (!existsSync42(skillMdPath)) {
     return null;
   }
   try {
-    const content = readFileSync28(skillMdPath, "utf-8");
+    const content = readFileSync30(skillMdPath, "utf-8");
     return parseSkillContentToCanonical(content, skillPath, sourceAgent);
   } catch {
     return null;
@@ -26594,7 +27410,7 @@ function translateSkillToAgent(canonical, targetAgent, options) {
   }
   const content = generateSkillContent(canonical, targetAgent, format, options);
   const filename = options?.outputFilename || "SKILL.md";
-  const targetDir = options?.outputDir || join40(format.skillsDir, canonical.name);
+  const targetDir = options?.outputDir || join43(format.skillsDir, canonical.name);
   return {
     success: true,
     content,
@@ -26769,7 +27585,7 @@ function writeTranslatedSkill(result, rootDir, options) {
         error: "Resolved output path escapes rootDir"
       };
     }
-    if (existsSync39(filePath) && options?.overwrite === false) {
+    if (existsSync42(filePath) && options?.overwrite === false) {
       return {
         success: false,
         path: filePath,
@@ -26777,10 +27593,10 @@ function writeTranslatedSkill(result, rootDir, options) {
         skipped: true
       };
     }
-    if (!existsSync39(targetPath)) {
-      mkdirSync21(targetPath, { recursive: true });
+    if (!existsSync42(targetPath)) {
+      mkdirSync23(targetPath, { recursive: true });
     }
-    writeFileSync20(filePath, result.content, "utf-8");
+    writeFileSync22(filePath, result.content, "utf-8");
     return { success: true, path: filePath };
   } catch (error) {
     return {
@@ -26963,16 +27779,16 @@ var getAgentSkillsDir = getSkillsDir;
 var getAgentConfigFile = getConfigFile;
 
 // src/manifest/index.ts
-import { readFileSync as readFileSync29, writeFileSync as writeFileSync21, existsSync as existsSync40 } from "fs";
-import { join as join41, dirname as dirname14 } from "path";
+import { readFileSync as readFileSync31, writeFileSync as writeFileSync23, existsSync as existsSync43 } from "fs";
+import { join as join44, dirname as dirname14 } from "path";
 import { parse as parseYaml12, stringify as stringifyYaml9 } from "yaml";
 var MANIFEST_FILENAMES = [".skills", ".skills.yaml", ".skills.yml", "skills.yaml"];
 function findManifestPath(startDir = process.cwd()) {
   let dir = startDir;
   while (dir !== dirname14(dir)) {
     for (const filename of MANIFEST_FILENAMES) {
-      const manifestPath = join41(dir, filename);
-      if (existsSync40(manifestPath)) {
+      const manifestPath = join44(dir, filename);
+      if (existsSync43(manifestPath)) {
         return manifestPath;
       }
     }
@@ -26982,11 +27798,11 @@ function findManifestPath(startDir = process.cwd()) {
 }
 function loadManifest(manifestPath) {
   const path4 = manifestPath || findManifestPath();
-  if (!path4 || !existsSync40(path4)) {
+  if (!path4 || !existsSync43(path4)) {
     return null;
   }
   try {
-    const content = readFileSync29(path4, "utf-8");
+    const content = readFileSync31(path4, "utf-8");
     const parsed = parseYaml12(content);
     if (!parsed || typeof parsed !== "object") {
       return null;
@@ -27028,7 +27844,7 @@ function normalizeSkills(skills) {
   }).filter((s) => s.source);
 }
 function saveManifest(manifest, manifestPath) {
-  const path4 = manifestPath || join41(process.cwd(), ".skills");
+  const path4 = manifestPath || join44(process.cwd(), ".skills");
   const content = stringifyYaml9({
     version: manifest.version || 1,
     skills: manifest.skills.map((s) => {
@@ -27041,7 +27857,7 @@ function saveManifest(manifest, manifestPath) {
     ...manifest.installMethod && { installMethod: manifest.installMethod },
     updatedAt: (/* @__PURE__ */ new Date()).toISOString()
   });
-  writeFileSync21(path4, content, "utf-8");
+  writeFileSync23(path4, content, "utf-8");
 }
 function addToManifest(source, options, manifestPath) {
   const existing = loadManifest(manifestPath) || {
@@ -27118,8 +27934,8 @@ function generateManifestFromInstalled(installedSkills) {
 }
 
 // src/quality/index.ts
-import { readFileSync as readFileSync30, existsSync as existsSync41 } from "fs";
-import { join as join42, basename as basename17 } from "path";
+import { readFileSync as readFileSync32, existsSync as existsSync44 } from "fs";
+import { join as join45, basename as basename17 } from "path";
 
 // src/quality/benchmark.ts
 var CATEGORY_BENCHMARKS = {
@@ -27721,9 +28537,9 @@ function evaluateSkillContent(content) {
   };
 }
 function evaluateSkillFile(filePath) {
-  if (!existsSync41(filePath)) return null;
+  if (!existsSync44(filePath)) return null;
   try {
-    const content = readFileSync30(filePath, "utf-8");
+    const content = readFileSync32(filePath, "utf-8");
     return evaluateSkillContent(content);
   } catch {
     return null;
@@ -27749,11 +28565,11 @@ function checkTokenBudget(content) {
   return null;
 }
 function evaluateSkillDirectory(dirPath) {
-  const skillMdPath = join42(dirPath, "SKILL.md");
-  if (existsSync41(skillMdPath)) {
+  const skillMdPath = join45(dirPath, "SKILL.md");
+  if (existsSync44(skillMdPath)) {
     const result = evaluateSkillFile(skillMdPath);
     if (result) {
-      const content = readFileSync30(skillMdPath, "utf-8");
+      const content = readFileSync32(skillMdPath, "utf-8");
       const nameWarning = checkNameDirectoryMatch(content, dirPath);
       if (nameWarning) result.warnings.push(nameWarning);
       const budgetWarning = checkTokenBudget(content);
@@ -27763,8 +28579,8 @@ function evaluateSkillDirectory(dirPath) {
   }
   const mdcFiles = ["index.mdc", `${basename17(dirPath)}.mdc`];
   for (const file of mdcFiles) {
-    const mdcPath = join42(dirPath, file);
-    if (existsSync41(mdcPath)) {
+    const mdcPath = join45(dirPath, file);
+    if (existsSync44(mdcPath)) {
       return evaluateSkillFile(mdcPath);
     }
   }
@@ -27934,8 +28750,8 @@ var AGENT_INSTRUCTION_TEMPLATES = {
 };
 
 // src/primer/analyzer.ts
-import { existsSync as existsSync42, readFileSync as readFileSync31, readdirSync as readdirSync12 } from "fs";
-import { join as join43, basename as basename18, relative as relative4, sep as sep4 } from "path";
+import { existsSync as existsSync45, readFileSync as readFileSync33, readdirSync as readdirSync13 } from "fs";
+import { join as join46, basename as basename18, relative as relative4, sep as sep4 } from "path";
 var PACKAGE_MANAGER_FILES = {
   "package-lock.json": "npm",
   "pnpm-lock.yaml": "pnpm",
@@ -28023,10 +28839,10 @@ var PrimerAnalyzer = class {
     return analysis;
   }
   loadPackageJson() {
-    const packageJsonPath = join43(this.projectPath, "package.json");
-    if (existsSync42(packageJsonPath)) {
+    const packageJsonPath = join46(this.projectPath, "package.json");
+    if (existsSync45(packageJsonPath)) {
       try {
-        const content = readFileSync31(packageJsonPath, "utf-8");
+        const content = readFileSync33(packageJsonPath, "utf-8");
         this.packageJson = JSON.parse(content);
       } catch {
         this.packageJson = null;
@@ -28037,9 +28853,9 @@ var PrimerAnalyzer = class {
     const scan = (dir, depth) => {
       if (depth > maxDepth) return;
       try {
-        const entries = readdirSync12(dir, { withFileTypes: true });
+        const entries = readdirSync13(dir, { withFileTypes: true });
         for (const entry of entries) {
-          const fullPath = join43(dir, entry.name);
+          const fullPath = join46(dir, entry.name);
           const relativePath = relative4(this.projectPath, fullPath);
           if (entry.name.startsWith(".") && entry.name !== ".github" && entry.name !== ".env.example") {
             if (!entry.isDirectory()) {
@@ -28084,10 +28900,10 @@ var PrimerAnalyzer = class {
         info.repository = String(repo.url);
       }
     }
-    const pyprojectPath = join43(this.projectPath, "pyproject.toml");
-    if (!this.packageJson && existsSync42(pyprojectPath)) {
+    const pyprojectPath = join46(this.projectPath, "pyproject.toml");
+    if (!this.packageJson && existsSync45(pyprojectPath)) {
       try {
-        const content = readFileSync31(pyprojectPath, "utf-8");
+        const content = readFileSync33(pyprojectPath, "utf-8");
         const nameMatch = content.match(/name\s*=\s*["']([^"']+)["']/);
         const versionMatch = content.match(/version\s*=\s*["']([^"']+)["']/);
         const descMatch = content.match(/description\s*=\s*["']([^"']+)["']/);
@@ -28097,10 +28913,10 @@ var PrimerAnalyzer = class {
       } catch {
       }
     }
-    const cargoPath = join43(this.projectPath, "Cargo.toml");
-    if (!this.packageJson && existsSync42(cargoPath)) {
+    const cargoPath = join46(this.projectPath, "Cargo.toml");
+    if (!this.packageJson && existsSync45(cargoPath)) {
       try {
-        const content = readFileSync31(cargoPath, "utf-8");
+        const content = readFileSync33(cargoPath, "utf-8");
         const nameMatch = content.match(/name\s*=\s*["']([^"']+)["']/);
         const versionMatch = content.match(/version\s*=\s*["']([^"']+)["']/);
         const descMatch = content.match(/description\s*=\s*["']([^"']+)["']/);
@@ -28280,8 +29096,8 @@ var PrimerAnalyzer = class {
     }
     if (this.hasFile("tsconfig.json")) {
       try {
-        const tsconfigPath = join43(this.projectPath, "tsconfig.json");
-        const content = readFileSync31(tsconfigPath, "utf-8");
+        const tsconfigPath = join46(this.projectPath, "tsconfig.json");
+        const content = readFileSync33(tsconfigPath, "utf-8");
         const tsconfig = JSON.parse(content.replace(/\/\/.*$/gm, "").replace(/,\s*}/g, "}"));
         const paths = tsconfig.compilerOptions?.paths;
         if (paths && Object.keys(paths).some((k) => k.startsWith("@"))) {
@@ -28310,8 +29126,8 @@ var PrimerAnalyzer = class {
       ci.provider = "github-actions";
       ci.configFile = ".github/workflows";
       try {
-        const workflowsDir = join43(this.projectPath, ".github/workflows");
-        const workflows = readdirSync12(workflowsDir);
+        const workflowsDir = join46(this.projectPath, ".github/workflows");
+        const workflows = readdirSync13(workflowsDir);
         const deployWorkflows = workflows.filter(
           (f) => f.includes("deploy") || f.includes("release") || f.includes("publish")
         );
@@ -28331,12 +29147,12 @@ var PrimerAnalyzer = class {
     env.hasEnvFile = this.hasFile(".env");
     env.hasEnvExample = this.hasFile(".env.example") || this.hasFile(".env.template") || this.hasFile(".env.sample");
     if (env.hasEnvExample) {
-      const envExamplePath = join43(
+      const envExamplePath = join46(
         this.projectPath,
         this.hasFile(".env.example") ? ".env.example" : this.hasFile(".env.template") ? ".env.template" : ".env.sample"
       );
       try {
-        const content = readFileSync31(envExamplePath, "utf-8");
+        const content = readFileSync33(envExamplePath, "utf-8");
         const variables = content.split("\n").filter((line) => line.trim() && !line.startsWith("#")).map((line) => line.split("=")[0].trim()).filter((v) => v);
         env.envVariables = variables;
       } catch {
@@ -28353,8 +29169,8 @@ var PrimerAnalyzer = class {
     docker.hasCompose = this.hasFile("docker-compose.yml") || this.hasFile("docker-compose.yaml") || this.hasFile("compose.yml");
     if (docker.hasDockerfile) {
       try {
-        const dockerfilePath = join43(this.projectPath, "Dockerfile");
-        const content = readFileSync31(dockerfilePath, "utf-8");
+        const dockerfilePath = join46(this.projectPath, "Dockerfile");
+        const content = readFileSync33(dockerfilePath, "utf-8");
         const fromMatch = content.match(/^FROM\s+(\S+)/m);
         if (fromMatch) {
           docker.baseImage = fromMatch[1];
@@ -28443,7 +29259,7 @@ var PrimerAnalyzer = class {
       }
       return false;
     }
-    return this.files.has(name) || existsSync42(join43(this.projectPath, name));
+    return this.files.has(name) || existsSync45(join46(this.projectPath, name));
   }
   getDepVersion(dep) {
     if (!this.packageJson) return void 0;
@@ -28465,10 +29281,10 @@ var PrimerAnalyzer = class {
   }
   readConfigFile(files) {
     for (const file of files) {
-      const filePath = join43(this.projectPath, file);
-      if (existsSync42(filePath)) {
+      const filePath = join46(this.projectPath, file);
+      if (existsSync45(filePath)) {
         try {
-          const content = readFileSync31(filePath, "utf-8");
+          const content = readFileSync33(filePath, "utf-8");
           if (file.endsWith(".json")) {
             return JSON.parse(content);
           }
@@ -28486,8 +29302,8 @@ function analyzePrimer(projectPath) {
 }
 
 // src/primer/generator.ts
-import { existsSync as existsSync43, mkdirSync as mkdirSync22, writeFileSync as writeFileSync22 } from "fs";
-import { join as join44, dirname as dirname15 } from "path";
+import { existsSync as existsSync46, mkdirSync as mkdirSync24, writeFileSync as writeFileSync24 } from "fs";
+import { join as join47, dirname as dirname15 } from "path";
 var ALL_AGENTS = Object.keys(AGENT_CONFIG);
 var markdownRenderer = {
   h1: (text) => `# ${text}`,
@@ -28651,14 +29467,14 @@ var PrimerGenerator = class {
   detectInstalledAgents() {
     const detected = [];
     for (const [agent, config] of Object.entries(AGENT_CONFIG)) {
-      const configPath = join44(this.projectPath, config.configFile);
-      const skillsPath = join44(this.projectPath, config.skillsDir);
-      if (existsSync43(configPath) || existsSync43(skillsPath)) {
+      const configPath = join47(this.projectPath, config.configFile);
+      const skillsPath = join47(this.projectPath, config.skillsDir);
+      if (existsSync46(configPath) || existsSync46(skillsPath)) {
         detected.push(agent);
       }
       if (config.altSkillsDirs) {
         for (const altDir of config.altSkillsDirs) {
-          if (existsSync43(join44(this.projectPath, altDir))) {
+          if (existsSync46(join47(this.projectPath, altDir))) {
             if (!detected.includes(agent)) {
               detected.push(agent);
             }
@@ -28678,7 +29494,7 @@ var PrimerGenerator = class {
     const template = AGENT_INSTRUCTION_TEMPLATES[agent] || this.getDefaultTemplate(agent, config);
     const content = this.generateContent(template);
     const outputDir = this.options.outputDir || this.projectPath;
-    const filepath = join44(outputDir, template.filename);
+    const filepath = join47(outputDir, template.filename);
     return {
       agent,
       filename: template.filename,
@@ -29051,10 +29867,10 @@ var PrimerGenerator = class {
   }
   writeInstruction(instruction) {
     const dir = dirname15(instruction.filepath);
-    if (!existsSync43(dir)) {
-      mkdirSync22(dir, { recursive: true });
+    if (!existsSync46(dir)) {
+      mkdirSync24(dir, { recursive: true });
     }
-    writeFileSync22(instruction.filepath, instruction.content, "utf-8");
+    writeFileSync24(instruction.filepath, instruction.content, "utf-8");
   }
   formatProjectType(type) {
     const typeMap = {
@@ -29068,402 +29884,135 @@ var PrimerGenerator = class {
     };
     return typeMap[type] || type;
   }
-  capitalize(str) {
-    return str.charAt(0).toUpperCase() + str.slice(1);
-  }
-};
-function generatePrimer(projectPath, options = {}) {
-  const generator = new PrimerGenerator(projectPath, options);
-  return generator.generate();
-}
-function generatePrimerForAgent(projectPath, agent, options = {}) {
-  return generatePrimer(projectPath, { ...options, agents: [agent] });
-}
-function analyzeForPrimer(projectPath) {
-  const generator = new PrimerGenerator(projectPath, { analyzeOnly: true });
-  const result = generator.generate();
-  return result.analysis;
-}
-
-// src/learning/types.ts
-var DEFAULT_LEARNING_CONFIG = {
-  minSessionLength: 10,
-  sensitivity: "medium",
-  autoApprove: false,
-  outputPath: "~/.skillkit/learned/",
-  categories: ["error_fix", "refactor", "workaround", "debugging", "convention"],
-  ignorePatterns: ["trivial_typo", "one_off_fix", "wip", "merge"]
-};
-
-// src/learning/config.ts
-import { existsSync as existsSync44, readFileSync as readFileSync32, writeFileSync as writeFileSync23, mkdirSync as mkdirSync23 } from "fs";
-import { join as join45, dirname as dirname16 } from "path";
-import { homedir as homedir14 } from "os";
-import yaml from "yaml";
-function getDefaultConfigPath() {
-  return join45(homedir14(), ".skillkit", "learning.yaml");
-}
-function getDefaultStorePath() {
-  return join45(homedir14(), ".skillkit", "learned", "patterns.json");
-}
-function loadLearningConfig(configPath) {
-  const path4 = configPath || getDefaultConfigPath();
-  if (!existsSync44(path4)) {
-    return DEFAULT_LEARNING_CONFIG;
-  }
-  try {
-    const content = readFileSync32(path4, "utf-8");
-    const config = yaml.parse(content);
-    return { ...DEFAULT_LEARNING_CONFIG, ...config };
-  } catch {
-    return DEFAULT_LEARNING_CONFIG;
-  }
-}
-function saveLearningConfig(config, configPath) {
-  const path4 = configPath || getDefaultConfigPath();
-  const dir = dirname16(path4);
-  if (!existsSync44(dir)) {
-    mkdirSync23(dir, { recursive: true });
-  }
-  const content = yaml.stringify(config);
-  writeFileSync23(path4, content);
-}
-function loadPatternStore(storePath) {
-  const path4 = storePath || getDefaultStorePath();
-  if (!existsSync44(path4)) {
-    return {
-      version: 1,
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      patterns: [],
-      evolvingPatterns: []
-    };
-  }
-  try {
-    const content = readFileSync32(path4, "utf-8");
-    return JSON.parse(content);
-  } catch {
-    return {
-      version: 1,
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      patterns: [],
-      evolvingPatterns: []
-    };
-  }
-}
-function savePatternStore(store, storePath) {
-  const path4 = storePath || getDefaultStorePath();
-  const dir = dirname16(path4);
-  if (!existsSync44(dir)) {
-    mkdirSync23(dir, { recursive: true });
-  }
-  store.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  const content = JSON.stringify(store, null, 2);
-  writeFileSync23(path4, content);
-}
-function addPattern(pattern, storePath) {
-  const store = loadPatternStore(storePath);
-  const existingIndex = store.patterns.findIndex((p) => p.id === pattern.id);
-  if (existingIndex >= 0) {
-    store.patterns[existingIndex] = pattern;
-  } else {
-    store.patterns.push(pattern);
-  }
-  savePatternStore(store, storePath);
-  return store;
-}
-function removePattern(patternId, storePath) {
-  const store = loadPatternStore(storePath);
-  store.patterns = store.patterns.filter((p) => p.id !== patternId);
-  store.evolvingPatterns = store.evolvingPatterns.filter((p) => p.id !== patternId);
-  savePatternStore(store, storePath);
-  return store;
-}
-function getPattern(patternId, storePath) {
-  const store = loadPatternStore(storePath);
-  return store.patterns.find((p) => p.id === patternId) || null;
-}
-function getEvolvingPattern(patternId, storePath) {
-  const store = loadPatternStore(storePath);
-  return store.evolvingPatterns.find((p) => p.id === patternId) || null;
-}
-function getAllPatterns(storePath) {
-  const store = loadPatternStore(storePath);
-  return store.patterns;
-}
-function getPatternsByCategory(category, storePath) {
-  const store = loadPatternStore(storePath);
-  return store.patterns.filter((p) => p.category === category);
-}
-function getApprovedPatterns(storePath) {
-  const store = loadPatternStore(storePath);
-  return store.patterns.filter((p) => p.approved);
-}
-
-// src/learning/git-analyzer.ts
-import { execSync as execSync7 } from "child_process";
-import { existsSync as existsSync45 } from "fs";
-import { join as join46 } from "path";
-function runGitCommand(command, cwd) {
-  try {
-    return execSync7(command, { cwd, encoding: "utf-8", maxBuffer: 10 * 1024 * 1024 });
-  } catch {
-    return "";
-  }
-}
-function isGitRepository(path4) {
-  return existsSync45(join46(path4, ".git"));
-}
-function getGitCommits(repoPath, options = {}) {
-  if (!isGitRepository(repoPath)) {
-    return [];
-  }
-  const limit = options.commits || 100;
-  const args = [
-    "log",
-    `--max-count=${limit}`,
-    "--format=%H|||%h|||%an|||%aI|||%s|||%b|||END_COMMIT",
-    "--name-status"
-  ];
-  if (options.since) {
-    args.push(`--since="${options.since}"`);
-  }
-  if (options.until) {
-    args.push(`--until="${options.until}"`);
-  }
-  if (options.branch) {
-    args.push(options.branch);
-  }
-  if (options.author) {
-    args.push(`--author="${options.author}"`);
-  }
-  const output = runGitCommand(`git ${args.join(" ")}`, repoPath);
-  if (!output) return [];
-  const commits = [];
-  const commitBlocks = output.split("END_COMMIT").filter((b) => b.trim());
-  for (const block of commitBlocks) {
-    const lines = block.trim().split("\n");
-    if (lines.length === 0) continue;
-    const headerLine = lines[0];
-    const parts = headerLine.split("|||");
-    if (parts.length < 5) continue;
-    const [hash, shortHash, author, date, message, body] = parts;
-    const files = [];
-    for (let i = 1; i < lines.length; i++) {
-      const line = lines[i].trim();
-      if (!line) continue;
-      const match = line.match(/^([AMDRT])\d*\t(.+?)(?:\t(.+))?$/);
-      if (match) {
-        const [, status, path4, oldPath] = match;
-        files.push({
-          path: path4,
-          status: parseFileStatus(status),
-          additions: 0,
-          deletions: 0,
-          oldPath: oldPath || void 0
-        });
-      }
-    }
-    commits.push({
-      hash,
-      shortHash,
-      author,
-      date,
-      message,
-      body: body || void 0,
-      files
-    });
-  }
-  return commits;
-}
-function parseFileStatus(status) {
-  switch (status) {
-    case "A":
-      return "added";
-    case "D":
-      return "deleted";
-    case "R":
-      return "renamed";
-    default:
-      return "modified";
-  }
-}
-function categorizeCommit(message, body) {
-  const text = `${message} ${body || ""}`.toLowerCase();
-  if (text.includes("fix") || text.includes("bug") || text.includes("error") || text.includes("issue")) {
-    return "error_fix";
-  }
-  if (text.includes("refactor") || text.includes("clean") || text.includes("simplify")) {
-    return "refactor";
-  }
-  if (text.includes("workaround") || text.includes("hack") || text.includes("temporary")) {
-    return "workaround";
-  }
-  if (text.includes("debug") || text.includes("log") || text.includes("trace")) {
-    return "debugging";
-  }
-  return null;
-}
-function shouldSkipCommit(commit, ignorePatterns) {
-  const message = commit.message.toLowerCase();
-  for (const pattern of ignorePatterns) {
-    if (message.includes(pattern.toLowerCase())) {
-      return true;
-    }
-  }
-  if (message.startsWith("merge ") || message.startsWith("wip")) {
-    return true;
-  }
-  if (commit.files.length === 0) {
-    return true;
+  capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
   }
-  return false;
+};
+function generatePrimer(projectPath, options = {}) {
+  const generator = new PrimerGenerator(projectPath, options);
+  return generator.generate();
 }
-function extractPatternFromCommit(commit) {
-  const category = categorizeCommit(commit.message, commit.body);
-  if (!category) return null;
-  const id = `git-${commit.shortHash}`;
-  const title = formatTitle(commit.message);
-  const problem = extractProblem(commit);
-  const solution = extractSolution(commit);
-  const context = extractContext(commit);
-  if (!problem || !solution) return null;
-  return {
-    id,
-    category,
-    title,
-    problem,
-    solution,
-    context,
-    extractedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    source: "git",
-    commitRange: { from: commit.hash, to: commit.hash },
-    approved: false,
-    confidence: calculateConfidence(commit, category)
-  };
+function generatePrimerForAgent(projectPath, agent, options = {}) {
+  return generatePrimer(projectPath, { ...options, agents: [agent] });
 }
-function formatTitle(message) {
-  return message.charAt(0).toUpperCase() + message.slice(1);
+function analyzeForPrimer(projectPath) {
+  const generator = new PrimerGenerator(projectPath, { analyzeOnly: true });
+  const result = generator.generate();
+  return result.analysis;
 }
-function extractProblem(commit) {
-  const message = commit.message.toLowerCase();
-  if (message.includes("fix:") || message.includes("fix(")) {
-    const match = commit.message.match(/fix[:(]\s*([^)]+)/i);
-    if (match) {
-      return `Issue: ${match[1]}`;
-    }
-  }
-  if (commit.body) {
-    const problemMatch = commit.body.match(/problem:?\s*(.+)/i);
-    if (problemMatch) {
-      return problemMatch[1].trim();
-    }
-  }
-  return `${commit.message} (from commit ${commit.shortHash})`;
+
+// src/learning/types.ts
+var DEFAULT_LEARNING_CONFIG = {
+  minSessionLength: 10,
+  sensitivity: "medium",
+  autoApprove: false,
+  outputPath: "~/.skillkit/learned/",
+  categories: ["error_fix", "refactor", "workaround", "debugging", "convention"],
+  ignorePatterns: ["trivial_typo", "one_off_fix", "wip", "merge"]
+};
+
+// src/learning/config.ts
+import { existsSync as existsSync47, readFileSync as readFileSync34, writeFileSync as writeFileSync25, mkdirSync as mkdirSync25 } from "fs";
+import { join as join48, dirname as dirname16 } from "path";
+import { homedir as homedir14 } from "os";
+import yaml from "yaml";
+function getDefaultConfigPath() {
+  return join48(homedir14(), ".skillkit", "learning.yaml");
 }
-function extractSolution(commit) {
-  if (commit.body) {
-    const solutionMatch = commit.body.match(/solution:?\s*(.+)/i);
-    if (solutionMatch) {
-      return solutionMatch[1].trim();
-    }
-  }
-  const files = commit.files.map((f) => f.path).join(", ");
-  return `Modified: ${files}`;
+function getDefaultStorePath() {
+  return join48(homedir14(), ".skillkit", "learned", "patterns.json");
 }
-function extractContext(commit) {
-  const files = commit.files;
-  const extensions = new Set(files.map((f) => f.path.split(".").pop() || ""));
-  const directories = new Set(files.map((f) => f.path.split("/")[0]));
-  const parts = [];
-  if (extensions.size > 0) {
-    parts.push(`Files: ${Array.from(extensions).filter((e) => e).join(", ")}`);
+function loadLearningConfig(configPath) {
+  const path4 = configPath || getDefaultConfigPath();
+  if (!existsSync47(path4)) {
+    return DEFAULT_LEARNING_CONFIG;
   }
-  if (directories.size > 0 && directories.size <= 3) {
-    parts.push(`Areas: ${Array.from(directories).join(", ")}`);
+  try {
+    const content = readFileSync34(path4, "utf-8");
+    const config = yaml.parse(content);
+    return { ...DEFAULT_LEARNING_CONFIG, ...config };
+  } catch {
+    return DEFAULT_LEARNING_CONFIG;
   }
-  return parts.join(". ") || "General codebase";
 }
-function calculateConfidence(commit, category) {
-  let confidence = 0.5;
-  if (commit.body && commit.body.length > 50) {
-    confidence += 0.1;
+function saveLearningConfig(config, configPath) {
+  const path4 = configPath || getDefaultConfigPath();
+  const dir = dirname16(path4);
+  if (!existsSync47(dir)) {
+    mkdirSync25(dir, { recursive: true });
   }
-  if (commit.message.match(/^(fix|feat|refactor|docs|test|chore)(\(.+\))?:/)) {
-    confidence += 0.1;
+  const content = yaml.stringify(config);
+  writeFileSync25(path4, content);
+}
+function loadPatternStore(storePath) {
+  const path4 = storePath || getDefaultStorePath();
+  if (!existsSync47(path4)) {
+    return {
+      version: 1,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      patterns: [],
+      evolvingPatterns: []
+    };
   }
-  if (commit.files.length > 0 && commit.files.length < 10) {
-    confidence += 0.1;
+  try {
+    const content = readFileSync34(path4, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return {
+      version: 1,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      patterns: [],
+      evolvingPatterns: []
+    };
   }
-  if (category === "error_fix" || category === "workaround") {
-    confidence += 0.05;
+}
+function savePatternStore(store, storePath) {
+  const path4 = storePath || getDefaultStorePath();
+  const dir = dirname16(path4);
+  if (!existsSync47(dir)) {
+    mkdirSync25(dir, { recursive: true });
   }
-  return Math.min(0.9, confidence);
+  store.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const content = JSON.stringify(store, null, 2);
+  writeFileSync25(path4, content);
 }
-function analyzeGitHistory(repoPath, options = {}) {
-  const commits = getGitCommits(repoPath, options);
-  const ignorePatterns = ["merge", "wip", "typo"];
-  const patterns = [];
-  const summary = {
-    totalCommits: commits.length,
-    totalFilesChanged: 0,
-    errorFixes: 0,
-    refactors: 0,
-    features: 0,
-    documentation: 0,
-    tests: 0
-  };
-  const languages = /* @__PURE__ */ new Set();
-  const frameworks = /* @__PURE__ */ new Set();
-  for (const commit of commits) {
-    if (shouldSkipCommit(commit, ignorePatterns)) {
-      continue;
-    }
-    summary.totalFilesChanged += commit.files.length;
-    for (const file of commit.files) {
-      const ext = file.path.split(".").pop()?.toLowerCase();
-      if (ext) {
-        if (["ts", "tsx"].includes(ext)) languages.add("TypeScript");
-        else if (["js", "jsx"].includes(ext)) languages.add("JavaScript");
-        else if (ext === "py") languages.add("Python");
-        else if (ext === "go") languages.add("Go");
-        else if (ext === "rs") languages.add("Rust");
-        else if (ext === "java") languages.add("Java");
-      }
-      if (file.path.includes("next")) frameworks.add("Next.js");
-      if (file.path.includes("react")) frameworks.add("React");
-      if (file.path.includes("vue")) frameworks.add("Vue");
-    }
-    const category = categorizeCommit(commit.message, commit.body);
-    if (category === "error_fix") summary.errorFixes++;
-    else if (category === "refactor") summary.refactors++;
-    if (commit.message.toLowerCase().includes("feat")) summary.features++;
-    if (commit.message.toLowerCase().includes("doc")) summary.documentation++;
-    if (commit.message.toLowerCase().includes("test")) summary.tests++;
-    const pattern = extractPatternFromCommit(commit);
-    if (pattern) {
-      patterns.push(pattern);
-    }
+function addPattern(pattern, storePath) {
+  const store = loadPatternStore(storePath);
+  const existingIndex = store.patterns.findIndex((p) => p.id === pattern.id);
+  if (existingIndex >= 0) {
+    store.patterns[existingIndex] = pattern;
+  } else {
+    store.patterns.push(pattern);
   }
-  const dates = commits.map((c) => c.date).sort();
-  return {
-    patterns,
-    commitCount: commits.length,
-    dateRange: {
-      from: dates[0] || "",
-      to: dates[dates.length - 1] || ""
-    },
-    languages: Array.from(languages),
-    frameworks: Array.from(frameworks),
-    summary
-  };
+  savePatternStore(store, storePath);
+  return store;
 }
-function getRecentBugFixes(repoPath, limit = 20) {
-  const result = analyzeGitHistory(repoPath, { commits: limit * 3 });
-  return result.patterns.filter((p) => p.category === "error_fix").slice(0, limit);
+function removePattern(patternId, storePath) {
+  const store = loadPatternStore(storePath);
+  store.patterns = store.patterns.filter((p) => p.id !== patternId);
+  store.evolvingPatterns = store.evolvingPatterns.filter((p) => p.id !== patternId);
+  savePatternStore(store, storePath);
+  return store;
 }
-function getRecentRefactors(repoPath, limit = 20) {
-  const result = analyzeGitHistory(repoPath, { commits: limit * 3 });
-  return result.patterns.filter((p) => p.category === "refactor").slice(0, limit);
+function getPattern(patternId, storePath) {
+  const store = loadPatternStore(storePath);
+  return store.patterns.find((p) => p.id === patternId) || null;
+}
+function getEvolvingPattern(patternId, storePath) {
+  const store = loadPatternStore(storePath);
+  return store.evolvingPatterns.find((p) => p.id === patternId) || null;
+}
+function getAllPatterns(storePath) {
+  const store = loadPatternStore(storePath);
+  return store.patterns;
+}
+function getPatternsByCategory(category, storePath) {
+  const store = loadPatternStore(storePath);
+  return store.patterns.filter((p) => p.category === category);
+}
+function getApprovedPatterns(storePath) {
+  const store = loadPatternStore(storePath);
+  return store.patterns.filter((p) => p.approved);
 }
 
 // src/learning/extractor.ts
@@ -29716,8 +30265,8 @@ function mergePatterns(existing, newPatterns) {
 }
 
 // src/learning/generator.ts
-import { writeFileSync as writeFileSync24, mkdirSync as mkdirSync24, existsSync as existsSync46 } from "fs";
-import { join as join47 } from "path";
+import { writeFileSync as writeFileSync26, mkdirSync as mkdirSync26, existsSync as existsSync48 } from "fs";
+import { join as join49 } from "path";
 import { homedir as homedir15 } from "os";
 function generateSkillFromPatterns(patterns, options = {}) {
   const minConfidence = options.minConfidence ?? 0.5;
@@ -29808,12 +30357,12 @@ function generateSkillContent2(name, patterns, category) {
   return lines.join("\n");
 }
 function saveGeneratedSkill(skill, outputDir) {
-  const dir = outputDir || join47(homedir15(), ".skillkit", "skills", "learned");
-  if (!existsSync46(dir)) {
-    mkdirSync24(dir, { recursive: true });
+  const dir = outputDir || join49(homedir15(), ".skillkit", "skills", "learned");
+  if (!existsSync48(dir)) {
+    mkdirSync26(dir, { recursive: true });
   }
-  const filepath = join47(dir, skill.filename);
-  writeFileSync24(filepath, skill.content);
+  const filepath = join49(dir, skill.filename);
+  writeFileSync26(filepath, skill.content);
   return filepath;
 }
 function generatePatternReport(patterns) {
@@ -30043,8 +30592,8 @@ var DEFAULT_PROFILE_CONFIG = {
 };
 
 // src/profiles/manager.ts
-import { existsSync as existsSync47, readFileSync as readFileSync33, writeFileSync as writeFileSync25, mkdirSync as mkdirSync25 } from "fs";
-import { join as join48, dirname as dirname17 } from "path";
+import { existsSync as existsSync49, readFileSync as readFileSync35, writeFileSync as writeFileSync27, mkdirSync as mkdirSync27 } from "fs";
+import { join as join50, dirname as dirname17 } from "path";
 import { homedir as homedir16 } from "os";
 import yaml2 from "yaml";
 var BUILTIN_PROFILES = [
@@ -30125,15 +30674,15 @@ var BUILTIN_PROFILES = [
   }
 ];
 function getConfigPath() {
-  return join48(homedir16(), ".skillkit", "profiles.yaml");
+  return join50(homedir16(), ".skillkit", "profiles.yaml");
 }
 function loadProfileConfig() {
   const path4 = getConfigPath();
-  if (!existsSync47(path4)) {
+  if (!existsSync49(path4)) {
     return DEFAULT_PROFILE_CONFIG;
   }
   try {
-    const content = readFileSync33(path4, "utf-8");
+    const content = readFileSync35(path4, "utf-8");
     return { ...DEFAULT_PROFILE_CONFIG, ...yaml2.parse(content) };
   } catch {
     return DEFAULT_PROFILE_CONFIG;
@@ -30142,10 +30691,10 @@ function loadProfileConfig() {
 function saveProfileConfig(config) {
   const path4 = getConfigPath();
   const dir = dirname17(path4);
-  if (!existsSync47(dir)) {
-    mkdirSync25(dir, { recursive: true });
+  if (!existsSync49(dir)) {
+    mkdirSync27(dir, { recursive: true });
   }
-  writeFileSync25(path4, yaml2.stringify(config));
+  writeFileSync27(path4, yaml2.stringify(config));
 }
 function getActiveProfile() {
   const config = loadProfileConfig();
@@ -30212,8 +30761,8 @@ var DEFAULT_GUIDELINE_CONFIG = {
 };
 
 // src/guidelines/manager.ts
-import { existsSync as existsSync48, readFileSync as readFileSync34, writeFileSync as writeFileSync26, mkdirSync as mkdirSync26 } from "fs";
-import { join as join49, dirname as dirname18 } from "path";
+import { existsSync as existsSync50, readFileSync as readFileSync36, writeFileSync as writeFileSync28, mkdirSync as mkdirSync28 } from "fs";
+import { join as join51, dirname as dirname18 } from "path";
 import { homedir as homedir17 } from "os";
 import yaml3 from "yaml";
 var BUILTIN_GUIDELINES = [
@@ -30391,15 +30940,15 @@ Types: feat, fix, docs, style, refactor, test, chore`
   }
 ];
 function getConfigPath2() {
-  return join49(homedir17(), ".skillkit", "guidelines.yaml");
+  return join51(homedir17(), ".skillkit", "guidelines.yaml");
 }
 function loadGuidelineConfig() {
   const path4 = getConfigPath2();
-  if (!existsSync48(path4)) {
+  if (!existsSync50(path4)) {
     return DEFAULT_GUIDELINE_CONFIG;
   }
   try {
-    const content = readFileSync34(path4, "utf-8");
+    const content = readFileSync36(path4, "utf-8");
     return { ...DEFAULT_GUIDELINE_CONFIG, ...yaml3.parse(content) };
   } catch {
     return DEFAULT_GUIDELINE_CONFIG;
@@ -30408,10 +30957,10 @@ function loadGuidelineConfig() {
 function saveGuidelineConfig(config) {
   const path4 = getConfigPath2();
   const dir = dirname18(path4);
-  if (!existsSync48(dir)) {
-    mkdirSync26(dir, { recursive: true });
+  if (!existsSync50(dir)) {
+    mkdirSync28(dir, { recursive: true });
   }
-  writeFileSync26(path4, yaml3.stringify(config));
+  writeFileSync28(path4, yaml3.stringify(config));
 }
 function getGuideline(id) {
   const builtin = BUILTIN_GUIDELINES.find((g) => g.id === id);
@@ -30493,7 +31042,7 @@ init_generator();
 
 // src/tree/serializer.ts
 init_types3();
-import { readFileSync as readFileSync35, writeFileSync as writeFileSync27, existsSync as existsSync49, mkdirSync as mkdirSync27 } from "fs";
+import { readFileSync as readFileSync37, writeFileSync as writeFileSync29, existsSync as existsSync51, mkdirSync as mkdirSync29 } from "fs";
 import { dirname as dirname19 } from "path";
 var TREE_FILE_NAME = "skill-tree.json";
 function serializeTree(tree) {
@@ -30505,18 +31054,18 @@ function deserializeTree(json) {
 }
 function saveTree(tree, path4) {
   const dir = dirname19(path4);
-  if (!existsSync49(dir)) {
-    mkdirSync27(dir, { recursive: true });
+  if (!existsSync51(dir)) {
+    mkdirSync29(dir, { recursive: true });
   }
   const json = serializeTree(tree);
-  writeFileSync27(path4, json, "utf-8");
+  writeFileSync29(path4, json, "utf-8");
 }
 function loadTree(path4) {
-  if (!existsSync49(path4)) {
+  if (!existsSync51(path4)) {
     return null;
   }
   try {
-    const json = readFileSync35(path4, "utf-8");
+    const json = readFileSync37(path4, "utf-8");
     return deserializeTree(json);
   } catch {
     return null;
@@ -31471,12 +32020,12 @@ function createExecutionManager(config) {
 }
 
 // src/execution/mode.ts
-import { existsSync as existsSync50, readFileSync as readFileSync36 } from "fs";
-import { join as join50 } from "path";
+import { existsSync as existsSync52, readFileSync as readFileSync38 } from "fs";
+import { join as join52 } from "path";
 import { homedir as homedir18 } from "os";
 var DEFAULT_MCP_CONFIG_PATHS = [
-  join50(homedir18(), ".mcp.json"),
-  join50(homedir18(), ".config", "claude", "mcp.json"),
+  join52(homedir18(), ".mcp.json"),
+  join52(homedir18(), ".config", "claude", "mcp.json"),
   ".mcp.json",
   "mcp.json"
 ];
@@ -31525,8 +32074,8 @@ function detectMcpServers(configPaths) {
   for (const configPath of configPaths) {
     try {
       const fullPath = configPath.startsWith("~") ? configPath.replace("~", process.env.HOME || "") : configPath;
-      if (existsSync50(fullPath)) {
-        const content = readFileSync36(fullPath, "utf-8");
+      if (existsSync52(fullPath)) {
+        const content = readFileSync38(fullPath, "utf-8");
         const config = JSON.parse(content);
         if (config.mcpServers) {
           servers.push(...Object.keys(config.mcpServers));
@@ -31664,8 +32213,8 @@ init_expansion();
 init_hybrid();
 
 // src/registry/community.ts
-import { readFileSync as readFileSync37, existsSync as existsSync51 } from "fs";
-import { join as join51, dirname as dirname20 } from "path";
+import { readFileSync as readFileSync39, existsSync as existsSync53 } from "fs";
+import { join as join53, dirname as dirname20 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var CommunityRegistry = class {
   constructor(skillsMdPath) {
@@ -31678,13 +32227,13 @@ var CommunityRegistry = class {
     if (this.loaded) return;
     this.loaded = true;
     const paths = this.skillsMdPath ? [this.skillsMdPath] : [
-      join51(process.cwd(), "registry", "SKILLS.md"),
-      join51(dirname20(fileURLToPath2(import.meta.url)), "..", "..", "..", "..", "registry", "SKILLS.md")
+      join53(process.cwd(), "registry", "SKILLS.md"),
+      join53(dirname20(fileURLToPath2(import.meta.url)), "..", "..", "..", "..", "registry", "SKILLS.md")
     ];
     for (const path4 of paths) {
-      if (!existsSync51(path4)) continue;
+      if (!existsSync53(path4)) continue;
       try {
-        const content = readFileSync37(path4, "utf-8");
+        const content = readFileSync39(path4, "utf-8");
         this.entries = this.parse(content);
         return;
       } catch {
@@ -31983,8 +32532,8 @@ var RelevanceRanker = class {
 };
 
 // src/parser/references.ts
-import { readdirSync as readdirSync13, statSync as statSync10, existsSync as existsSync52 } from "fs";
-import { join as join52 } from "path";
+import { readdirSync as readdirSync14, statSync as statSync10, existsSync as existsSync54 } from "fs";
+import { join as join54 } from "path";
 var REFERENCE_DIRS = ["references", "resources", "docs", "examples", "assets", "scripts"];
 var DIR_TYPE_MAP = {
   references: "resource",
@@ -31997,8 +32546,8 @@ var DIR_TYPE_MAP = {
 function discoverReferences(skillDir) {
   const refs = [];
   for (const dir of REFERENCE_DIRS) {
-    const fullPath = join52(skillDir, dir);
-    if (!existsSync52(fullPath)) continue;
+    const fullPath = join54(skillDir, dir);
+    if (!existsSync54(fullPath)) continue;
     try {
       const stat = statSync10(fullPath);
       if (!stat.isDirectory()) continue;
@@ -32007,14 +32556,14 @@ function discoverReferences(skillDir) {
     }
     const type = DIR_TYPE_MAP[dir] || "resource";
     try {
-      const entries = readdirSync13(fullPath);
+      const entries = readdirSync14(fullPath);
       for (const entry of entries) {
-        const entryPath = join52(fullPath, entry);
+        const entryPath = join54(fullPath, entry);
         try {
           const entryStat = statSync10(entryPath);
           if (entryStat.isFile()) {
             refs.push({
-              path: join52(dir, entry),
+              path: join54(dir, entry),
               type,
               name: entry
             });
@@ -33181,7 +33730,7 @@ var SecretsAnalyzer = class {
 
 // src/scanner/scanner.ts
 import { readdir } from "fs/promises";
-import { join as join53, basename as basename20 } from "path";
+import { join as join55, basename as basename20 } from "path";
 var SEVERITY_ORDER = {
   ["critical" /* CRITICAL */]: 5,
   ["high" /* HIGH */]: 4,
@@ -33200,7 +33749,7 @@ async function discoverFiles(dirPath) {
       return;
     }
     for (const entry of entries) {
-      const fullPath = join53(dir, entry.name);
+      const fullPath = join55(dir, entry.name);
       if (entry.name.startsWith(".") && entry.name !== ".env" && !entry.name.startsWith(".env.")) continue;
       if (entry.name === "node_modules") continue;
       if (entry.isDirectory()) {
@@ -33294,7 +33843,7 @@ var SkillScanner = class {
 
 // src/scanner/reporter.ts
 import { basename as basename21 } from "path";
-var SCANNER_VERSION = true ? "1.17.0" : "0.0.0";
+var SCANNER_VERSION = true ? "1.19.0" : "0.0.0";
 var SEVERITY_COLORS = {
   ["critical" /* CRITICAL */]: "\x1B[91m",
   ["high" /* HIGH */]: "\x1B[31m",
@@ -33567,8 +34116,8 @@ function getDefaultSeverity(category) {
 }
 
 // src/validation/spec-validator.ts
-import { readFileSync as readFileSync38, existsSync as existsSync53 } from "fs";
-import { join as join54, basename as basename22 } from "path";
+import { readFileSync as readFileSync40, existsSync as existsSync55 } from "fs";
+import { join as join56, basename as basename22 } from "path";
 var NAME_PATTERN = /^[a-z0-9]+(-[a-z0-9]+)*$/;
 var SPEC_VERSION = "1.0";
 var SpecValidator = class {
@@ -33576,12 +34125,12 @@ var SpecValidator = class {
     const checks = [];
     const errors = [];
     const warnings = [];
-    const skillMdPath = skillPath.endsWith(".md") ? skillPath : join54(skillPath, "SKILL.md");
-    if (!existsSync53(skillMdPath)) {
+    const skillMdPath = skillPath.endsWith(".md") ? skillPath : join56(skillPath, "SKILL.md");
+    if (!existsSync55(skillMdPath)) {
       errors.push(`SKILL.md not found at ${skillMdPath}`);
       return { valid: false, errors, warnings, specVersion: SPEC_VERSION, checks };
     }
-    const raw = readFileSync38(skillMdPath, "utf-8");
+    const raw = readFileSync40(skillMdPath, "utf-8");
     const { frontmatter, body } = stripFrontmatter(raw);
     const hasName = typeof frontmatter.name === "string" && frontmatter.name.length > 0;
     checks.push({
@@ -33648,7 +34197,7 @@ var SpecValidator = class {
         });
       }
       if (hasName) {
-        const skillDir = skillPath.endsWith(".md") ? join54(skillPath, "..") : skillPath;
+        const skillDir = skillPath.endsWith(".md") ? join56(skillPath, "..") : skillPath;
         const dirName = basename22(skillDir);
         const nameStr = frontmatter.name;
         const nameMatchesDir = nameStr === dirName;
@@ -33681,8 +34230,8 @@ var SpecValidator = class {
 };
 
 // src/agents-md/generator.ts
-import { existsSync as existsSync54, readFileSync as readFileSync39 } from "fs";
-import { join as join55 } from "path";
+import { existsSync as existsSync56, readFileSync as readFileSync41 } from "fs";
+import { join as join57 } from "path";
 function escapeTableCell(text) {
   return text.replace(/\|/g, "\\|").replace(/\n/g, " ");
 }
@@ -33711,7 +34260,7 @@ var AgentsMdGenerator = class {
       managed: true
     });
     if (this.config.includeSkills !== false) {
-      const skillsContent = this.generateSkillsSection(findAllSkills([join55(this.config.projectPath, "skills")]));
+      const skillsContent = this.generateSkillsSection(findAllSkills([join57(this.config.projectPath, "skills")]));
       if (skillsContent) {
         sections.push({
           id: "installed-skills",
@@ -33754,7 +34303,7 @@ var AgentsMdGenerator = class {
     return {
       content,
       sections,
-      path: join55(this.config.projectPath, "AGENTS.md")
+      path: join57(this.config.projectPath, "AGENTS.md")
     };
   }
   generateSkillsSection(skills) {
@@ -33785,12 +34334,12 @@ var AgentsMdGenerator = class {
     return lines.join("\n");
   }
   generateBuildSection() {
-    const packageJsonPath = join55(this.config.projectPath, "package.json");
-    if (!existsSync54(packageJsonPath)) {
+    const packageJsonPath = join57(this.config.projectPath, "package.json");
+    if (!existsSync56(packageJsonPath)) {
       return "";
     }
     try {
-      const pkg = JSON.parse(readFileSync39(packageJsonPath, "utf-8"));
+      const pkg = JSON.parse(readFileSync41(packageJsonPath, "utf-8"));
       const scripts = pkg.scripts;
       if (!scripts || Object.keys(scripts).length === 0) {
         return "";
@@ -33942,7 +34491,7 @@ var AgentsMdParser = class {
 };
 
 // src/save/extractor.ts
-import { existsSync as existsSync55, readFileSync as readFileSync40 } from "fs";
+import { existsSync as existsSync57, readFileSync as readFileSync42 } from "fs";
 import { basename as basename23, extname as extname7 } from "path";
 import TurndownService from "turndown";
 var LANGUAGE_MAP = {
@@ -34044,10 +34593,10 @@ var ContentExtractor = class {
     };
   }
   extractFromFile(filePath, options) {
-    if (!existsSync55(filePath)) {
+    if (!existsSync57(filePath)) {
       throw new Error(`File not found: ${filePath}`);
     }
-    const raw = readFileSync40(filePath, "utf-8");
+    const raw = readFileSync42(filePath, "utf-8");
     const name = basename23(filePath);
     const language = this.detectLanguage(name);
     const isCode = language !== void 0 && language !== "markdown";
@@ -34247,8 +34796,8 @@ var AutoTagger = class {
 };
 
 // src/save/skill-generator.ts
-import { mkdirSync as mkdirSync28, writeFileSync as writeFileSync28 } from "fs";
-import { join as join56 } from "path";
+import { mkdirSync as mkdirSync30, writeFileSync as writeFileSync30 } from "fs";
+import { join as join58 } from "path";
 import { homedir as homedir19 } from "os";
 var MAX_NAME_LENGTH = 64;
 var SUMMARY_LINE_LIMIT = 100;
@@ -34269,14 +34818,14 @@ var SkillGenerator = class {
 ${body}
 `;
     const outputDir = options.outputDir ?? this.defaultOutputDir(name, options.global);
-    mkdirSync28(outputDir, { recursive: true });
-    const skillPath = join56(outputDir, "SKILL.md");
-    writeFileSync28(skillPath, skillMd, "utf-8");
+    mkdirSync30(outputDir, { recursive: true });
+    const skillPath = join58(outputDir, "SKILL.md");
+    writeFileSync30(skillPath, skillMd, "utf-8");
     if (needsSplit) {
-      const refsDir = join56(outputDir, "references");
-      mkdirSync28(refsDir, { recursive: true });
-      writeFileSync28(
-        join56(refsDir, "full-content.md"),
+      const refsDir = join58(outputDir, "references");
+      mkdirSync30(refsDir, { recursive: true });
+      writeFileSync30(
+        join58(refsDir, "full-content.md"),
         content.content,
         "utf-8"
       );
@@ -34318,9 +34867,9 @@ ${yamlTags}` : null,
   }
   defaultOutputDir(name, global) {
     if (global) {
-      return join56(homedir19(), ".skillkit", "skills", name);
+      return join58(homedir19(), ".skillkit", "skills", name);
     }
-    return join56(".skillkit", "skills", name);
+    return join58(".skillkit", "skills", name);
   }
 };
 export {
@@ -34335,6 +34884,7 @@ export {
   AISkillGenerator,
   ALL_AGENT_DISCOVERY_PATHS,
   APIBasedCompressor,
+  ActivityLog,
   AgentFrontmatter,
   AgentHook,
   AgentLocation,
@@ -34406,6 +34956,7 @@ export {
   INDEX_CACHE_HOURS,
   INDEX_PATH,
   InjectionDetector,
+  IssuePlanner,
   KNOWN_SKILL_REPOS,
   LearningConsolidator,
   LearningStore,
@@ -34462,6 +35013,7 @@ export {
   STEP_HANDLERS,
   SecretsAnalyzer,
   SessionEndHook,
+  SessionExplainer,
   SessionManager,
   SessionStartHook,
   Severity,
@@ -34485,6 +35037,7 @@ export {
   SkillWizard,
   SkillkitConfig,
   SkillsSource,
+  SnapshotManager,
   SpecValidator,
   StaticAnalyzer,
   TAG_TO_CATEGORY,
@@ -34548,6 +35101,7 @@ export {
   createHookManager,
   createHybridSearchPipeline,
   createInitialState,
+  createIssuePlanner,
   createMarketplaceAggregator,
   createMemoryCompressor,
   createMemoryEnabledEngine,