@goondocks/myco 0.2.7 → 0.2.9

package/dist/main-5W4ADOBG.js

@@ -0,0 +1,3224 @@
+import { createRequire as __cr } from 'node:module'; const require = __cr(import.meta.url);
+import {
+  VaultWriter,
+  bareSessionId,
+  formatMemoryBody,
+  formatSessionBody,
+  sessionNoteId,
+  sessionRelativePath,
+  sessionWikilink
+} from "./chunk-ZTZVX5E6.js";
+import {
+  ARTIFACT_TYPES,
+  DaemonLogger,
+  VectorIndex,
+  createEmbeddingProvider,
+  createLlmProvider,
+  generateEmbedding,
+  indexNote,
+  initFts,
+  rebuildIndex
+} from "./chunk-AOMX45LH.js";
+import {
+  MycoIndex
+} from "./chunk-PA3VMINE.js";
+import {
+  external_exports,
+  loadConfig,
+  require_dist
+} from "./chunk-UIIZRTJU.js";
+import {
+  EventBuffer
+} from "./chunk-I7PMGO6S.js";
+import {
+  AgentRegistry,
+  claudeCodeAdapter,
+  createPerProjectAdapter,
+  extensionForMimeType
+} from "./chunk-TWDS6MSU.js";
+import {
+  AI_RESPONSE_PREVIEW_CHARS,
+  CANDIDATE_CONTENT_PREVIEW,
+  CHARS_PER_TOKEN,
+  CLASSIFICATION_MAX_TOKENS,
+  COMMAND_PREVIEW_CHARS,
+  CONTENT_SNIPPET_CHARS,
+  CONTEXT_SESSION_PREVIEW_CHARS,
+  EMBEDDING_INPUT_LIMIT,
+  EXTRACTION_MAX_TOKENS,
+  FILE_WATCH_STABILITY_MS,
+  LINEAGE_RECENT_SESSIONS_LIMIT,
+  MAX_SLUG_LENGTH,
+  PROMPT_CONTEXT_MAX_MEMORIES,
+  PROMPT_CONTEXT_MIN_LENGTH,
+  PROMPT_CONTEXT_MIN_SIMILARITY,
+  PROMPT_PREVIEW_CHARS,
+  RELATED_MEMORIES_LIMIT,
+  SESSION_CONTEXT_MAX_PLANS,
+  STALE_BUFFER_MAX_AGE_MS,
+  SUMMARY_MAX_TOKENS,
+  TITLE_MAX_TOKENS
+} from "./chunk-NYNEJ5QY.js";
+import {
+  __toESM
+} from "./chunk-PZUWP5VK.js";
+
+// src/daemon/server.ts
+import http from "http";
+import fs from "fs";
+import path from "path";
+var DaemonServer = class {
+  port = 0;
+  server = null;
+  vaultDir;
+  logger;
+  routes = /* @__PURE__ */ new Map();
+  constructor(config) {
+    this.vaultDir = config.vaultDir;
+    this.logger = config.logger;
+    this.registerDefaultRoutes();
+  }
+  registerRoute(method, routePath, handler) {
+    this.routes.set(`${method} ${routePath}`, { method, handler });
+  }
+  async start() {
+    return new Promise((resolve3, reject) => {
+      this.server = http.createServer((req, res) => this.handleRequest(req, res));
+      this.server.on("error", reject);
+      this.server.listen(0, "127.0.0.1", () => {
+        const addr = this.server.address();
+        this.port = addr.port;
+        this.writeDaemonJson();
+        this.logger.info("daemon", "Server started", { port: this.port });
+        resolve3();
+      });
+    });
+  }
+  async stop() {
+    return new Promise((resolve3) => {
+      this.removeDaemonJson();
+      if (this.server) {
+        this.server.close(() => {
+          this.logger.info("daemon", "Server stopped");
+          resolve3();
+        });
+      } else {
+        resolve3();
+      }
+    });
+  }
+  registerDefaultRoutes() {
+    this.registerRoute("GET", "/health", async () => ({
+      myco: true,
+      pid: process.pid,
+      uptime: process.uptime()
+    }));
+  }
+  async handleRequest(req, res) {
+    const key = `${req.method} ${req.url}`;
+    const route = this.routes.get(key);
+    if (!route) {
+      res.writeHead(404, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "not found" }));
+      return;
+    }
+    try {
+      const body = req.method === "POST" ? await readBody(req) : void 0;
+      const result = await route.handler(body);
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify(result));
+    } catch (error) {
+      this.logger.error("daemon", "Request handler error", {
+        path: req.url,
+        error: error.message
+      });
+      res.writeHead(500, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: error.message }));
+    }
+  }
+  updateDaemonJsonSessions(sessions) {
+    const jsonPath = path.join(this.vaultDir, "daemon.json");
+    try {
+      const info = JSON.parse(fs.readFileSync(jsonPath, "utf-8"));
+      info.sessions = sessions;
+      fs.writeFileSync(jsonPath, JSON.stringify(info, null, 2));
+    } catch {
+    }
+  }
+  writeDaemonJson() {
+    const info = {
+      pid: process.pid,
+      port: this.port,
+      started: (/* @__PURE__ */ new Date()).toISOString(),
+      sessions: []
+    };
+    const jsonPath = path.join(this.vaultDir, "daemon.json");
+    fs.writeFileSync(jsonPath, JSON.stringify(info, null, 2));
+  }
+  removeDaemonJson() {
+    const jsonPath = path.join(this.vaultDir, "daemon.json");
+    try {
+      fs.unlinkSync(jsonPath);
+    } catch {
+    }
+  }
+};
+function readBody(req) {
+  return new Promise((resolve3, reject) => {
+    let data = "";
+    req.on("data", (chunk) => {
+      data += chunk;
+    });
+    req.on("end", () => {
+      try {
+        resolve3(data ? JSON.parse(data) : {});
+      } catch (e) {
+        reject(e);
+      }
+    });
+    req.on("error", reject);
+  });
+}
+
+// src/daemon/lifecycle.ts
+var SessionRegistry = class {
+  _sessions = /* @__PURE__ */ new Map();
+  graceTimer = null;
+  gracePeriod;
+  onEmpty;
+  constructor(options) {
+    this.gracePeriod = options.gracePeriod;
+    this.onEmpty = options.onEmpty;
+  }
+  get sessions() {
+    return [...this._sessions.keys()];
+  }
+  register(sessionId, metadata) {
+    if (!this._sessions.has(sessionId)) {
+      this._sessions.set(sessionId, metadata ?? { started_at: (/* @__PURE__ */ new Date()).toISOString() });
+    }
+    this.cancelGrace();
+  }
+  getSession(sessionId) {
+    const meta = this._sessions.get(sessionId);
+    if (!meta) return void 0;
+    return { id: sessionId, ...meta };
+  }
+  unregister(sessionId) {
+    this._sessions.delete(sessionId);
+    if (this._sessions.size === 0) {
+      this.startGrace();
+    }
+  }
+  destroy() {
+    this.cancelGrace();
+    this._sessions.clear();
+  }
+  startGrace() {
+    this.cancelGrace();
+    this.graceTimer = setTimeout(() => {
+      if (this._sessions.size === 0) {
+        this.onEmpty();
+      }
+    }, this.gracePeriod * 1e3);
+  }
+  cancelGrace() {
+    if (this.graceTimer) {
+      clearTimeout(this.graceTimer);
+      this.graceTimer = null;
+    }
+  }
+};
+
+// src/daemon/batch.ts
+var BatchManager = class {
+  batches = /* @__PURE__ */ new Map();
+  onBatchClosed;
+  constructor(onBatchClosed) {
+    this.onBatchClosed = onBatchClosed;
+  }
+  addEvent(event) {
+    const sid = event.session_id;
+    if (event.type === "user_prompt") {
+      const current = this.batches.get(sid);
+      if (current && current.length > 0) {
+        Promise.resolve(this.onBatchClosed(current)).catch((err) => {
+          console.error(`[mycod] batch callback error: ${err.message}`);
+        });
+      }
+      this.batches.set(sid, [event]);
+    } else {
+      const current = this.batches.get(sid);
+      if (current) {
+        current.push(event);
+      }
+    }
+  }
+  finalize(sessionId) {
+    const current = this.batches.get(sessionId);
+    this.batches.delete(sessionId);
+    return current ?? [];
+  }
+  hasOpenBatch(sessionId) {
+    return this.batches.has(sessionId) && this.batches.get(sessionId).length > 0;
+  }
+  batchSize(sessionId) {
+    return this.batches.get(sessionId)?.length ?? 0;
+  }
+};
+
+// src/prompts/index.ts
+import fs2 from "fs";
+import path2 from "path";
+import { fileURLToPath } from "url";
+var __dirname = path2.dirname(fileURLToPath(import.meta.url));
+var promptCache = /* @__PURE__ */ new Map();
+function loadPrompt(name) {
+  let cached = promptCache.get(name);
+  if (!cached) {
+    cached = fs2.readFileSync(path2.join(__dirname, `${name}.md`), "utf-8").trim();
+    promptCache.set(name, cached);
+  }
+  return cached;
+}
+function interpolate(template, vars) {
+  let result = template;
+  for (const [key, value] of Object.entries(vars)) {
+    result = result.replaceAll(`{{${key}}}`, value);
+  }
+  return result;
+}
+function buildExtractionPrompt(sessionId, eventCount, toolSummary) {
+  return interpolate(loadPrompt("extraction"), {
+    sessionId,
+    eventCount: String(eventCount),
+    toolSummary
+  });
+}
+function buildSummaryPrompt(sessionId, user, content) {
+  return interpolate(loadPrompt("summary"), {
+    sessionId,
+    user,
+    content
+  });
+}
+function buildTitlePrompt(summary, sessionId) {
+  return interpolate(loadPrompt("title"), {
+    summary,
+    sessionId
+  });
+}
+var ARTIFACT_TYPE_DESCRIPTIONS = [
+  '"spec" \u2014 Design specifications, architecture documents',
+  '"plan" \u2014 Implementation plans, roadmaps',
+  '"rfc" \u2014 Requests for comment, proposals',
+  '"doc" \u2014 Documentation, guides, READMEs',
+  '"other" \u2014 Other substantive documents'
+];
+function buildSimilarityPrompt(currentSummary, candidateSummary) {
+  return interpolate(loadPrompt("session-similarity"), {
+    currentSummary,
+    candidateSummary
+  });
+}
+function buildClassificationPrompt(sessionId, candidates) {
+  const fileList = candidates.map((c) => {
+    const truncated = c.content.slice(0, CANDIDATE_CONTENT_PREVIEW);
+    return `### ${c.path}
+\`\`\`
+${truncated}
+\`\`\``;
+  }).join("\n\n");
+  return interpolate(loadPrompt("classification"), {
+    sessionId,
+    fileList,
+    artifactTypes: ARTIFACT_TYPE_DESCRIPTIONS.map((d) => `- ${d}`).join("\n"),
+    validTypes: ARTIFACT_TYPES.join("|")
+  });
+}
+
+// src/intelligence/response.ts
+var REASONING_PATTERNS = [
+  // <think>...</think>answer  (DeepSeek, Qwen, GLM, many others)
+  /<think>[\s\S]*?<\/think>\s*/gi,
+  // Implicit opening: reasoning...</think>answer  (GLM-4.7 observed)
+  /^[\s\S]*?<\/think>\s*/i,
+  // <reasoning>...</reasoning>answer
+  /<reasoning>[\s\S]*?<\/reasoning>\s*/gi,
+  // <|thinking|>...<|/thinking|>answer
+  /<\|thinking\|>[\s\S]*?<\|\/thinking\|>\s*/gi
+];
+function stripReasoningTokens(text) {
+  if (!text) return text;
+  for (const pattern of REASONING_PATTERNS) {
+    const stripped = text.replace(pattern, "").trim();
+    if (stripped && stripped !== text.trim()) {
+      return stripped;
+    }
+  }
+  return text;
+}
+function extractJson(text) {
+  const cleaned = stripReasoningTokens(text);
+  const fenceMatch = cleaned.match(/```(?:json)?\s*\n?([\s\S]*?)\n?```/);
+  if (fenceMatch) {
+    return JSON.parse(fenceMatch[1].trim());
+  }
+  const objectMatch = cleaned.match(/\{[\s\S]*\}/);
+  if (objectMatch) {
+    return JSON.parse(objectMatch[0]);
+  }
+  return JSON.parse(cleaned);
+}
+function extractNumber(text) {
+  const cleaned = stripReasoningTokens(text).trim();
+  const match = cleaned.match(/(\d+\.?\d*)/);
+  if (match) return parseFloat(match[1]);
+  return parseFloat(cleaned);
+}
+
+// src/daemon/processor.ts
+var ClassificationResponseSchema = external_exports.object({
+  artifacts: external_exports.array(external_exports.object({
+    source_path: external_exports.string(),
+    artifact_type: external_exports.enum(ARTIFACT_TYPES),
+    title: external_exports.string(),
+    tags: external_exports.array(external_exports.string()).default([])
+  })).default([])
+});
+var BufferProcessor = class {
+  constructor(backend, contextWindow = 8192) {
+    this.backend = backend;
+    this.contextWindow = contextWindow;
+  }
+  truncateForContext(data, maxTokens) {
+    const available = this.contextWindow - maxTokens;
+    const dataTokens = Math.ceil(data.length / CHARS_PER_TOKEN);
+    if (dataTokens <= available) return data;
+    const charBudget = available * CHARS_PER_TOKEN;
+    return data.slice(0, charBudget);
+  }
+  async process(events, sessionId) {
+    const rawPrompt = this.buildPromptForExtraction(events, sessionId);
+    const prompt = this.truncateForContext(rawPrompt, EXTRACTION_MAX_TOKENS);
+    try {
+      const response = await this.backend.summarize(prompt, { maxTokens: EXTRACTION_MAX_TOKENS });
+      const parsed = extractJson(response.text);
+      return {
+        summary: parsed.summary,
+        observations: parsed.observations ?? [],
+        degraded: false
+      };
+    } catch (error) {
+      return {
+        summary: `LLM processing failed for session ${sessionId}. ${events.length} events captured. Error: ${error.message}`,
+        observations: [],
+        degraded: true
+      };
+    }
+  }
+  buildPromptForExtraction(events, sessionId) {
+    const toolSummary = this.summarizeEvents(events);
+    return buildExtractionPrompt(sessionId, events.length, toolSummary);
+  }
+  async summarizeSession(conversationMarkdown, sessionId, user) {
+    const truncatedContent = this.truncateForContext(conversationMarkdown, SUMMARY_MAX_TOKENS);
+    const summaryPrompt = buildSummaryPrompt(sessionId, user ?? "unknown", truncatedContent);
+    let summaryText;
+    try {
+      const response = await this.backend.summarize(summaryPrompt, { maxTokens: SUMMARY_MAX_TOKENS });
+      summaryText = stripReasoningTokens(response.text);
+    } catch (error) {
+      summaryText = `Session ${sessionId} \u2014 summarization failed: ${error.message}`;
+    }
+    const titlePrompt = buildTitlePrompt(summaryText, sessionId);
+    let title;
+    try {
+      const response = await this.backend.summarize(titlePrompt, { maxTokens: TITLE_MAX_TOKENS });
+      title = stripReasoningTokens(response.text).trim();
+    } catch {
+      title = `Session ${sessionId}`;
+    }
+    return { summary: summaryText, title };
+  }
+  async classifyArtifacts(candidates, sessionId) {
+    if (candidates.length === 0) return [];
+    const prompt = this.buildPromptForClassification(candidates, sessionId);
+    const response = await this.backend.summarize(prompt, { maxTokens: CLASSIFICATION_MAX_TOKENS });
+    const raw = extractJson(response.text);
+    const parsed = ClassificationResponseSchema.parse(raw);
+    return parsed.artifacts;
+  }
+  buildPromptForClassification(candidates, sessionId) {
+    return buildClassificationPrompt(sessionId, candidates);
+  }
+  summarizeEvents(events) {
+    const toolCounts = /* @__PURE__ */ new Map();
+    const filesAccessed = /* @__PURE__ */ new Set();
+    const prompts = [];
+    const aiResponses = [];
+    for (const event of events) {
+      if (event.type === "user_prompt") {
+        const prompt = String(event.prompt ?? "");
+        if (prompt) prompts.push(prompt.slice(0, PROMPT_PREVIEW_CHARS));
+        continue;
+      }
+      if (event.type === "ai_response") {
+        const content = String(event.content ?? "");
+        if (content) aiResponses.push(content.slice(0, AI_RESPONSE_PREVIEW_CHARS));
+        continue;
+      }
+      const tool = String(event.tool_name ?? event.tool ?? "unknown");
+      toolCounts.set(tool, (toolCounts.get(tool) ?? 0) + 1);
+      const input = event.tool_input ?? event.input;
+      if (input?.path) filesAccessed.add(String(input.path));
+      if (input?.file_path) filesAccessed.add(String(input.file_path));
+      if (input?.command) filesAccessed.add(`[cmd] ${String(input.command).slice(0, COMMAND_PREVIEW_CHARS)}`);
+    }
+    const lines = [];
+    if (prompts.length > 0) {
+      lines.push("### User Prompts");
+      for (const p of prompts) {
+        lines.push(`- "${p}"`);
+      }
+    }
+    lines.push("\n### Tool Usage");
+    for (const [tool, count] of toolCounts) {
+      lines.push(`- ${tool}: ${count} calls`);
+    }
+    if (filesAccessed.size > 0) {
+      lines.push("\n### Files Accessed");
+      for (const file of filesAccessed) {
+        lines.push(`- ${file}`);
+      }
+    }
+    if (aiResponses.length > 0) {
+      lines.push("\n### AI Responses");
+      for (const r of aiResponses) {
+        lines.push(`- "${r}"`);
+      }
+    }
+    return lines.join("\n");
+  }
+};
+
+// src/daemon/lineage.ts
+import fs3 from "fs";
+import path3 from "path";
+var LINEAGE_IMMEDIATE_GAP_SECONDS = 5;
+var LINEAGE_FALLBACK_MAX_HOURS = 24;
+var LINEAGE_SIMILARITY_THRESHOLD = 0.7;
+var LINEAGE_SIMILARITY_HIGH_CONFIDENCE = 0.9;
+var LINEAGE_SIMILARITY_CANDIDATES = 3;
+var LINEAGE_SIMILARITY_MAX_TOKENS = 8;
+var MS_PER_SECOND = 1e3;
+var MS_PER_HOUR = 36e5;
+var LineageGraph = class {
+  state;
+  filePath;
+  constructor(vaultDir) {
+    this.filePath = path3.join(vaultDir, "lineage.json");
+    fs3.mkdirSync(path3.dirname(this.filePath), { recursive: true });
+    this.state = this.load();
+  }
+  addLink(link) {
+    if (this.state.links.some((l) => l.parent === link.parent && l.child === link.child)) return;
+    this.state.links.push({ ...link, timestamp: link.timestamp ?? (/* @__PURE__ */ new Date()).toISOString() });
+    this.persist();
+  }
+  /** Register an artifact (plan, spec, doc) as produced by a session. */
+  registerArtifactForSession(sessionId, artifactId) {
+    if (!this.state.sessionArtifacts[sessionId]) this.state.sessionArtifacts[sessionId] = [];
+    if (!this.state.sessionArtifacts[sessionId].includes(artifactId)) {
+      this.state.sessionArtifacts[sessionId].push(artifactId);
+      this.persist();
+    }
+  }
+  /** @deprecated Use registerArtifactForSession instead */
+  registerPlanForSession(sessionId, planId) {
+    this.registerArtifactForSession(sessionId, planId);
+  }
+  detectLineage(childSessionId, firstPrompt) {
+    for (const [sessionId, artifactIds] of Object.entries(this.state.sessionArtifacts)) {
+      if (sessionId === childSessionId) continue;
+      for (const artifactId of artifactIds) {
+        if (firstPrompt.includes(artifactId)) {
+          const link = { parent: sessionId, child: childSessionId, signal: "plan_reference", confidence: "high" };
+          this.addLink(link);
+          return link;
+        }
+      }
+    }
+    return null;
+  }
+  detectHeuristicParent(childSessionId, context, recentSessions, activeSessions, firstPrompt) {
+    const startedAt = new Date(context.started_at).getTime();
+    for (const session of recentSessions) {
+      if (!session.ended) continue;
+      const endedAt = new Date(session.ended).getTime();
+      const gapSeconds = (startedAt - endedAt) / MS_PER_SECOND;
+      if (gapSeconds >= 0 && gapSeconds <= LINEAGE_IMMEDIATE_GAP_SECONDS) {
+        const link = { parent: session.id, child: childSessionId, signal: "clear", confidence: "high" };
+        this.addLink(link);
+        return link;
+      }
+    }
+    for (const session of activeSessions) {
+      if (session.id === childSessionId) continue;
+      const link = { parent: session.id, child: childSessionId, signal: "clear_active", confidence: "high" };
+      this.addLink(link);
+      return link;
+    }
+    if (context.branch) {
+      for (const session of recentSessions) {
+        if (!session.ended || !session.branch) continue;
+        if (session.branch !== context.branch) continue;
+        const endedAt = new Date(session.ended).getTime();
+        const hoursAgo = (startedAt - endedAt) / MS_PER_HOUR;
+        if (hoursAgo >= 0 && hoursAgo <= LINEAGE_FALLBACK_MAX_HOURS) {
+          const link = { parent: session.id, child: childSessionId, signal: "inferred", confidence: "medium" };
+          this.addLink(link);
+          return link;
+        }
+      }
+    }
+    if (firstPrompt) {
+      return this.detectLineage(childSessionId, firstPrompt);
+    }
+    return null;
+  }
+  getLinks() {
+    return [...this.state.links];
+  }
+  getChildren(sessionId) {
+    return this.state.links.filter((l) => l.parent === sessionId).map((l) => l.child);
+  }
+  getParent(sessionId) {
+    return this.state.links.find((l) => l.child === sessionId)?.parent;
+  }
+  load() {
+    try {
+      const raw = JSON.parse(fs3.readFileSync(this.filePath, "utf-8"));
+      const sessionArtifacts = raw.sessionArtifacts ?? raw.sessionPlans ?? {};
+      return { links: raw.links ?? [], sessionArtifacts };
+    } catch {
+      return { links: [], sessionArtifacts: {} };
+    }
+  }
+  persist() {
+    const tmp = this.filePath + ".tmp";
+    fs3.writeFileSync(tmp, JSON.stringify(this.state, null, 2));
+    fs3.renameSync(tmp, this.filePath);
+  }
+};
+
+// node_modules/chokidar/index.js
+import { EventEmitter } from "events";
+import { stat as statcb, Stats } from "fs";
+import { readdir as readdir2, stat as stat3 } from "fs/promises";
+import * as sp2 from "path";
+
+// node_modules/readdirp/index.js
+import { lstat, readdir, realpath, stat } from "fs/promises";
+import { join as pjoin, relative as prelative, resolve as presolve, sep as psep } from "path";
+import { Readable } from "stream";
+var EntryTypes = {
+  FILE_TYPE: "files",
+  DIR_TYPE: "directories",
+  FILE_DIR_TYPE: "files_directories",
+  EVERYTHING_TYPE: "all"
+};
+var defaultOptions = {
+  root: ".",
+  fileFilter: (_entryInfo) => true,
+  directoryFilter: (_entryInfo) => true,
+  type: EntryTypes.FILE_TYPE,
+  lstat: false,
+  depth: 2147483648,
+  alwaysStat: false,
+  highWaterMark: 4096
+};
+Object.freeze(defaultOptions);
+var RECURSIVE_ERROR_CODE = "READDIRP_RECURSIVE_ERROR";
+var NORMAL_FLOW_ERRORS = /* @__PURE__ */ new Set(["ENOENT", "EPERM", "EACCES", "ELOOP", RECURSIVE_ERROR_CODE]);
+var ALL_TYPES = [
+  EntryTypes.DIR_TYPE,
+  EntryTypes.EVERYTHING_TYPE,
+  EntryTypes.FILE_DIR_TYPE,
+  EntryTypes.FILE_TYPE
+];
+var DIR_TYPES = /* @__PURE__ */ new Set([
+  EntryTypes.DIR_TYPE,
+  EntryTypes.EVERYTHING_TYPE,
+  EntryTypes.FILE_DIR_TYPE
+]);
+var FILE_TYPES = /* @__PURE__ */ new Set([
+  EntryTypes.EVERYTHING_TYPE,
+  EntryTypes.FILE_DIR_TYPE,
+  EntryTypes.FILE_TYPE
+]);
+var isNormalFlowError = (error) => NORMAL_FLOW_ERRORS.has(error.code);
+var wantBigintFsStats = process.platform === "win32";
+var emptyFn = (_entryInfo) => true;
+var normalizeFilter = (filter) => {
+  if (filter === void 0)
+    return emptyFn;
+  if (typeof filter === "function")
+    return filter;
+  if (typeof filter === "string") {
+    const fl = filter.trim();
+    return (entry) => entry.basename === fl;
+  }
+  if (Array.isArray(filter)) {
+    const trItems = filter.map((item) => item.trim());
+    return (entry) => trItems.some((f) => entry.basename === f);
+  }
+  return emptyFn;
+};
+var ReaddirpStream = class extends Readable {
+  parents;
+  reading;
+  parent;
+  _stat;
+  _maxDepth;
+  _wantsDir;
+  _wantsFile;
+  _wantsEverything;
+  _root;
+  _isDirent;
+  _statsProp;
+  _rdOptions;
+  _fileFilter;
+  _directoryFilter;
+  constructor(options = {}) {
+    super({
+      objectMode: true,
+      autoDestroy: true,
+      highWaterMark: options.highWaterMark
+    });
+    const opts = { ...defaultOptions, ...options };
+    const { root, type } = opts;
+    this._fileFilter = normalizeFilter(opts.fileFilter);
+    this._directoryFilter = normalizeFilter(opts.directoryFilter);
+    const statMethod = opts.lstat ? lstat : stat;
+    if (wantBigintFsStats) {
+      this._stat = (path8) => statMethod(path8, { bigint: true });
+    } else {
+      this._stat = statMethod;
+    }
+    this._maxDepth = opts.depth != null && Number.isSafeInteger(opts.depth) ? opts.depth : defaultOptions.depth;
+    this._wantsDir = type ? DIR_TYPES.has(type) : false;
+    this._wantsFile = type ? FILE_TYPES.has(type) : false;
+    this._wantsEverything = type === EntryTypes.EVERYTHING_TYPE;
+    this._root = presolve(root);
+    this._isDirent = !opts.alwaysStat;
+    this._statsProp = this._isDirent ? "dirent" : "stats";
+    this._rdOptions = { encoding: "utf8", withFileTypes: this._isDirent };
+    this.parents = [this._exploreDir(root, 1)];
+    this.reading = false;
+    this.parent = void 0;
+  }
+  async _read(batch) {
+    if (this.reading)
+      return;
+    this.reading = true;
+    try {
+      while (!this.destroyed && batch > 0) {
+        const par = this.parent;
+        const fil = par && par.files;
+        if (fil && fil.length > 0) {
+          const { path: path8, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path8));
+          const awaited = await Promise.all(slice);
+          for (const entry of awaited) {
+            if (!entry)
+              continue;
+            if (this.destroyed)
+              return;
+            const entryType = await this._getEntryType(entry);
+            if (entryType === "directory" && this._directoryFilter(entry)) {
+              if (depth <= this._maxDepth) {
+                this.parents.push(this._exploreDir(entry.fullPath, depth + 1));
+              }
+              if (this._wantsDir) {
+                this.push(entry);
+                batch--;
+              }
+            } else if ((entryType === "file" || this._includeAsFile(entry)) && this._fileFilter(entry)) {
+              if (this._wantsFile) {
+                this.push(entry);
+                batch--;
+              }
+            }
+          }
+        } else {
+          const parent = this.parents.pop();
+          if (!parent) {
+            this.push(null);
+            break;
+          }
+          this.parent = await parent;
+          if (this.destroyed)
+            return;
+        }
+      }
+    } catch (error) {
+      this.destroy(error);
+    } finally {
+      this.reading = false;
+    }
+  }
+  async _exploreDir(path8, depth) {
+    let files;
+    try {
+      files = await readdir(path8, this._rdOptions);
+    } catch (error) {
+      this._onError(error);
+    }
+    return { files, depth, path: path8 };
+  }
+  async _formatEntry(dirent, path8) {
+    let entry;
+    const basename3 = this._isDirent ? dirent.name : dirent;
+    try {
+      const fullPath = presolve(pjoin(path8, basename3));
+      entry = { path: prelative(this._root, fullPath), fullPath, basename: basename3 };
+      entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
+    } catch (err) {
+      this._onError(err);
+      return;
+    }
+    return entry;
+  }
+  _onError(err) {
+    if (isNormalFlowError(err) && !this.destroyed) {
+      this.emit("warn", err);
+    } else {
+      this.destroy(err);
+    }
+  }
+  async _getEntryType(entry) {
+    if (!entry && this._statsProp in entry) {
+      return "";
+    }
+    const stats = entry[this._statsProp];
+    if (stats.isFile())
+      return "file";
+    if (stats.isDirectory())
+      return "directory";
+    if (stats && stats.isSymbolicLink()) {
+      const full = entry.fullPath;
+      try {
+        const entryRealPath = await realpath(full);
+        const entryRealPathStats = await lstat(entryRealPath);
+        if (entryRealPathStats.isFile()) {
+          return "file";
+        }
+        if (entryRealPathStats.isDirectory()) {
+          const len = entryRealPath.length;
+          if (full.startsWith(entryRealPath) && full.substr(len, 1) === psep) {
+            const recursiveError = new Error(`Circular symlink detected: "${full}" points to "${entryRealPath}"`);
+            recursiveError.code = RECURSIVE_ERROR_CODE;
+            return this._onError(recursiveError);
+          }
+          return "directory";
+        }
+      } catch (error) {
+        this._onError(error);
+        return "";
+      }
+    }
+  }
+  _includeAsFile(entry) {
+    const stats = entry && entry[this._statsProp];
+    return stats && this._wantsEverything && !stats.isDirectory();
+  }
+};
+function readdirp(root, options = {}) {
+  let type = options.entryType || options.type;
+  if (type === "both")
+    type = EntryTypes.FILE_DIR_TYPE;
+  if (type)
+    options.type = type;
+  if (!root) {
+    throw new Error("readdirp: root argument is required. Usage: readdirp(root, options)");
+  } else if (typeof root !== "string") {
+    throw new TypeError("readdirp: root argument must be a string. Usage: readdirp(root, options)");
+  } else if (type && !ALL_TYPES.includes(type)) {
+    throw new Error(`readdirp: Invalid type passed. Use one of ${ALL_TYPES.join(", ")}`);
+  }
+  options.root = root;
+  return new ReaddirpStream(options);
+}
+
+// node_modules/chokidar/handler.js
+import { watch as fs_watch, unwatchFile, watchFile } from "fs";
+import { realpath as fsrealpath, lstat as lstat2, open, stat as stat2 } from "fs/promises";
+import { type as osType } from "os";
+import * as sp from "path";
+var STR_DATA = "data";
+var STR_END = "end";
+var STR_CLOSE = "close";
+var EMPTY_FN = () => {
+};
+var pl = process.platform;
+var isWindows = pl === "win32";
+var isMacos = pl === "darwin";
+var isLinux = pl === "linux";
+var isFreeBSD = pl === "freebsd";
+var isIBMi = osType() === "OS400";
+var EVENTS = {
+  ALL: "all",
+  READY: "ready",
+  ADD: "add",
+  CHANGE: "change",
+  ADD_DIR: "addDir",
+  UNLINK: "unlink",
+  UNLINK_DIR: "unlinkDir",
+  RAW: "raw",
+  ERROR: "error"
+};
+var EV = EVENTS;
+var THROTTLE_MODE_WATCH = "watch";
+var statMethods = { lstat: lstat2, stat: stat2 };
+var KEY_LISTENERS = "listeners";
+var KEY_ERR = "errHandlers";
+var KEY_RAW = "rawEmitters";
+var HANDLER_KEYS = [KEY_LISTENERS, KEY_ERR, KEY_RAW];
+var binaryExtensions = /* @__PURE__ */ new Set([
+  "3dm",
+  "3ds",
+  "3g2",
+  "3gp",
+  "7z",
+  "a",
+  "aac",
+  "adp",
+  "afdesign",
+  "afphoto",
+  "afpub",
+  "ai",
+  "aif",
+  "aiff",
+  "alz",
+  "ape",
+  "apk",
+  "appimage",
+  "ar",
+  "arj",
+  "asf",
+  "au",
+  "avi",
+  "bak",
+  "baml",
+  "bh",
+  "bin",
+  "bk",
+  "bmp",
+  "btif",
+  "bz2",
+  "bzip2",
+  "cab",
+  "caf",
+  "cgm",
+  "class",
+  "cmx",
+  "cpio",
+  "cr2",
+  "cur",
+  "dat",
+  "dcm",
+  "deb",
+  "dex",
+  "djvu",
+  "dll",
+  "dmg",
+  "dng",
+  "doc",
+  "docm",
+  "docx",
+  "dot",
+  "dotm",
+  "dra",
+  "DS_Store",
+  "dsk",
+  "dts",
+  "dtshd",
+  "dvb",
+  "dwg",
+  "dxf",
+  "ecelp4800",
+  "ecelp7470",
+  "ecelp9600",
+  "egg",
+  "eol",
+  "eot",
+  "epub",
+  "exe",
+  "f4v",
+  "fbs",
+  "fh",
+  "fla",
+  "flac",
+  "flatpak",
+  "fli",
+  "flv",
+  "fpx",
+  "fst",
+  "fvt",
+  "g3",
+  "gh",
+  "gif",
+  "graffle",
+  "gz",
+  "gzip",
+  "h261",
+  "h263",
+  "h264",
+  "icns",
+  "ico",
+  "ief",
+  "img",
+  "ipa",
+  "iso",
+  "jar",
+  "jpeg",
+  "jpg",
+  "jpgv",
+  "jpm",
+  "jxr",
+  "key",
+  "ktx",
+  "lha",
+  "lib",
+  "lvp",
+  "lz",
+  "lzh",
+  "lzma",
+  "lzo",
+  "m3u",
+  "m4a",
+  "m4v",
+  "mar",
+  "mdi",
+  "mht",
+  "mid",
+  "midi",
+  "mj2",
+  "mka",
+  "mkv",
+  "mmr",
+  "mng",
+  "mobi",
+  "mov",
+  "movie",
+  "mp3",
+  "mp4",
+  "mp4a",
+  "mpeg",
+  "mpg",
+  "mpga",
+  "mxu",
+  "nef",
+  "npx",
+  "numbers",
+  "nupkg",
+  "o",
+  "odp",
+  "ods",
+  "odt",
+  "oga",
+  "ogg",
+  "ogv",
+  "otf",
+  "ott",
+  "pages",
+  "pbm",
+  "pcx",
+  "pdb",
+  "pdf",
+  "pea",
+  "pgm",
+  "pic",
+  "png",
+  "pnm",
+  "pot",
+  "potm",
+  "potx",
+  "ppa",
+  "ppam",
+  "ppm",
+  "pps",
+  "ppsm",
+  "ppsx",
+  "ppt",
+  "pptm",
+  "pptx",
+  "psd",
+  "pya",
+  "pyc",
+  "pyo",
+  "pyv",
+  "qt",
+  "rar",
+  "ras",
+  "raw",
+  "resources",
+  "rgb",
+  "rip",
+  "rlc",
+  "rmf",
+  "rmvb",
+  "rpm",
+  "rtf",
+  "rz",
+  "s3m",
+  "s7z",
+  "scpt",
+  "sgi",
+  "shar",
+  "snap",
+  "sil",
+  "sketch",
+  "slk",
+  "smv",
+  "snk",
+  "so",
+  "stl",
+  "suo",
+  "sub",
+  "swf",
+  "tar",
+  "tbz",
+  "tbz2",
+  "tga",
+  "tgz",
+  "thmx",
+  "tif",
+  "tiff",
+  "tlz",
+  "ttc",
+  "ttf",
+  "txz",
+  "udf",
+  "uvh",
+  "uvi",
+  "uvm",
+  "uvp",
+  "uvs",
+  "uvu",
+  "viv",
+  "vob",
+  "war",
+  "wav",
+  "wax",
+  "wbmp",
+  "wdp",
+  "weba",
+  "webm",
+  "webp",
+  "whl",
+  "wim",
+  "wm",
+  "wma",
+  "wmv",
+  "wmx",
+  "woff",
+  "woff2",
+  "wrm",
+  "wvx",
+  "xbm",
+  "xif",
+  "xla",
+  "xlam",
+  "xls",
+  "xlsb",
+  "xlsm",
+  "xlsx",
+  "xlt",
+  "xltm",
+  "xltx",
+  "xm",
+  "xmind",
+  "xpi",
+  "xpm",
+  "xwd",
+  "xz",
+  "z",
+  "zip",
+  "zipx"
+]);
+var isBinaryPath = (filePath) => binaryExtensions.has(sp.extname(filePath).slice(1).toLowerCase());
+var foreach = (val, fn) => {
+  if (val instanceof Set) {
+    val.forEach(fn);
+  } else {
+    fn(val);
+  }
+};
+var addAndConvert = (main2, prop, item) => {
+  let container = main2[prop];
+  if (!(container instanceof Set)) {
+    main2[prop] = container = /* @__PURE__ */ new Set([container]);
+  }
+  container.add(item);
+};
+var clearItem = (cont) => (key) => {
+  const set = cont[key];
+  if (set instanceof Set) {
+    set.clear();
+  } else {
+    delete cont[key];
+  }
+};
+var delFromSet = (main2, prop, item) => {
+  const container = main2[prop];
+  if (container instanceof Set) {
+    container.delete(item);
+  } else if (container === item) {
+    delete main2[prop];
+  }
+};
+var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
+var FsWatchInstances = /* @__PURE__ */ new Map();
+function createFsWatchInstance(path8, options, listener, errHandler, emitRaw) {
+  const handleEvent = (rawEvent, evPath) => {
+    listener(path8);
+    emitRaw(rawEvent, evPath, { watchedPath: path8 });
+    if (evPath && path8 !== evPath) {
+      fsWatchBroadcast(sp.resolve(path8, evPath), KEY_LISTENERS, sp.join(path8, evPath));
+    }
+  };
+  try {
+    return fs_watch(path8, {
+      persistent: options.persistent
+    }, handleEvent);
+  } catch (error) {
+    errHandler(error);
+    return void 0;
+  }
+}
+var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
+  const cont = FsWatchInstances.get(fullPath);
+  if (!cont)
+    return;
+  foreach(cont[listenerType], (listener) => {
+    listener(val1, val2, val3);
+  });
+};
+var setFsWatchListener = (path8, fullPath, options, handlers) => {
+  const { listener, errHandler, rawEmitter } = handlers;
+  let cont = FsWatchInstances.get(fullPath);
+  let watcher;
+  if (!options.persistent) {
+    watcher = createFsWatchInstance(path8, options, listener, errHandler, rawEmitter);
+    if (!watcher)
+      return;
+    return watcher.close.bind(watcher);
+  }
+  if (cont) {
+    addAndConvert(cont, KEY_LISTENERS, listener);
+    addAndConvert(cont, KEY_ERR, errHandler);
+    addAndConvert(cont, KEY_RAW, rawEmitter);
+  } else {
+    watcher = createFsWatchInstance(
+      path8,
+      options,
+      fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
+      errHandler,
+      // no need to use broadcast here
+      fsWatchBroadcast.bind(null, fullPath, KEY_RAW)
+    );
+    if (!watcher)
+      return;
+    watcher.on(EV.ERROR, async (error) => {
+      const broadcastErr = fsWatchBroadcast.bind(null, fullPath, KEY_ERR);
+      if (cont)
+        cont.watcherUnusable = true;
+      if (isWindows && error.code === "EPERM") {
+        try {
+          const fd = await open(path8, "r");
+          await fd.close();
+          broadcastErr(error);
+        } catch (err) {
+        }
+      } else {
+        broadcastErr(error);
+      }
+    });
+    cont = {
+      listeners: listener,
+      errHandlers: errHandler,
+      rawEmitters: rawEmitter,
+      watcher
+    };
+    FsWatchInstances.set(fullPath, cont);
+  }
+  return () => {
+    delFromSet(cont, KEY_LISTENERS, listener);
+    delFromSet(cont, KEY_ERR, errHandler);
+    delFromSet(cont, KEY_RAW, rawEmitter);
+    if (isEmptySet(cont.listeners)) {
+      cont.watcher.close();
+      FsWatchInstances.delete(fullPath);
+      HANDLER_KEYS.forEach(clearItem(cont));
+      cont.watcher = void 0;
+      Object.freeze(cont);
+    }
+  };
+};
+var FsWatchFileInstances = /* @__PURE__ */ new Map();
+var setFsWatchFileListener = (path8, fullPath, options, handlers) => {
+  const { listener, rawEmitter } = handlers;
+  let cont = FsWatchFileInstances.get(fullPath);
+  const copts = cont && cont.options;
+  if (copts && (copts.persistent < options.persistent || copts.interval > options.interval)) {
+    unwatchFile(fullPath);
+    cont = void 0;
+  }
+  if (cont) {
+    addAndConvert(cont, KEY_LISTENERS, listener);
+    addAndConvert(cont, KEY_RAW, rawEmitter);
+  } else {
+    cont = {
+      listeners: listener,
+      rawEmitters: rawEmitter,
+      options,
+      watcher: watchFile(fullPath, options, (curr, prev) => {
+        foreach(cont.rawEmitters, (rawEmitter2) => {
+          rawEmitter2(EV.CHANGE, fullPath, { curr, prev });
+        });
+        const currmtime = curr.mtimeMs;
+        if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
+          foreach(cont.listeners, (listener2) => listener2(path8, curr));
+        }
+      })
+    };
+    FsWatchFileInstances.set(fullPath, cont);
+  }
+  return () => {
+    delFromSet(cont, KEY_LISTENERS, listener);
+    delFromSet(cont, KEY_RAW, rawEmitter);
+    if (isEmptySet(cont.listeners)) {
+      FsWatchFileInstances.delete(fullPath);
+      unwatchFile(fullPath);
+      cont.options = cont.watcher = void 0;
+      Object.freeze(cont);
+    }
+  };
+};
+var NodeFsHandler = class {
+  fsw;
+  _boundHandleError;
+  constructor(fsW) {
+    this.fsw = fsW;
+    this._boundHandleError = (error) => fsW._handleError(error);
+  }
+  /**
+   * Watch file for changes with fs_watchFile or fs_watch.
+   * @param path to file or dir
+   * @param listener on fs change
+   * @returns closer for the watcher instance
+   */
+  _watchWithNodeFs(path8, listener) {
+    const opts = this.fsw.options;
+    const directory = sp.dirname(path8);
+    const basename3 = sp.basename(path8);
+    const parent = this.fsw._getWatchedDir(directory);
+    parent.add(basename3);
+    const absolutePath = sp.resolve(path8);
+    const options = {
+      persistent: opts.persistent
+    };
+    if (!listener)
+      listener = EMPTY_FN;
+    let closer;
+    if (opts.usePolling) {
+      const enableBin = opts.interval !== opts.binaryInterval;
+      options.interval = enableBin && isBinaryPath(basename3) ? opts.binaryInterval : opts.interval;
+      closer = setFsWatchFileListener(path8, absolutePath, options, {
+        listener,
+        rawEmitter: this.fsw._emitRaw
+      });
+    } else {
+      closer = setFsWatchListener(path8, absolutePath, options, {
+        listener,
+        errHandler: this._boundHandleError,
+        rawEmitter: this.fsw._emitRaw
+      });
+    }
+    return closer;
+  }
+  /**
+   * Watch a file and emit add event if warranted.
+   * @returns closer for the watcher instance
+   */
+  _handleFile(file, stats, initialAdd) {
+    if (this.fsw.closed) {
+      return;
+    }
+    const dirname3 = sp.dirname(file);
+    const basename3 = sp.basename(file);
+    const parent = this.fsw._getWatchedDir(dirname3);
+    let prevStats = stats;
+    if (parent.has(basename3))
+      return;
+    const listener = async (path8, newStats) => {
+      if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
+        return;
+      if (!newStats || newStats.mtimeMs === 0) {
+        try {
+          const newStats2 = await stat2(file);
+          if (this.fsw.closed)
+            return;
+          const at = newStats2.atimeMs;
+          const mt = newStats2.mtimeMs;
+          if (!at || at <= mt || mt !== prevStats.mtimeMs) {
+            this.fsw._emit(EV.CHANGE, file, newStats2);
+          }
+          if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
+            this.fsw._closeFile(path8);
+            prevStats = newStats2;
+            const closer2 = this._watchWithNodeFs(file, listener);
+            if (closer2)
+              this.fsw._addPathCloser(path8, closer2);
+          } else {
+            prevStats = newStats2;
+          }
+        } catch (error) {
+          this.fsw._remove(dirname3, basename3);
+        }
+      } else if (parent.has(basename3)) {
+        const at = newStats.atimeMs;
+        const mt = newStats.mtimeMs;
+        if (!at || at <= mt || mt !== prevStats.mtimeMs) {
+          this.fsw._emit(EV.CHANGE, file, newStats);
+        }
+        prevStats = newStats;
+      }
+    };
+    const closer = this._watchWithNodeFs(file, listener);
+    if (!(initialAdd && this.fsw.options.ignoreInitial) && this.fsw._isntIgnored(file)) {
+      if (!this.fsw._throttle(EV.ADD, file, 0))
+        return;
+      this.fsw._emit(EV.ADD, file, stats);
+    }
+    return closer;
+  }
+  /**
+   * Handle symlinks encountered while reading a dir.
+   * @param entry returned by readdirp
+   * @param directory path of dir being read
+   * @param path of this item
+   * @param item basename of this item
+   * @returns true if no more processing is needed for this entry.
+   */
+  async _handleSymlink(entry, directory, path8, item) {
+    if (this.fsw.closed) {
+      return;
+    }
+    const full = entry.fullPath;
+    const dir = this.fsw._getWatchedDir(directory);
+    if (!this.fsw.options.followSymlinks) {
+      this.fsw._incrReadyCount();
+      let linkPath;
+      try {
+        linkPath = await fsrealpath(path8);
+      } catch (e) {
+        this.fsw._emitReady();
+        return true;
+      }
+      if (this.fsw.closed)
+        return;
+      if (dir.has(item)) {
+        if (this.fsw._symlinkPaths.get(full) !== linkPath) {
+          this.fsw._symlinkPaths.set(full, linkPath);
+          this.fsw._emit(EV.CHANGE, path8, entry.stats);
+        }
+      } else {
+        dir.add(item);
+        this.fsw._symlinkPaths.set(full, linkPath);
+        this.fsw._emit(EV.ADD, path8, entry.stats);
+      }
+      this.fsw._emitReady();
+      return true;
+    }
+    if (this.fsw._symlinkPaths.has(full)) {
+      return true;
+    }
+    this.fsw._symlinkPaths.set(full, true);
+  }
+  _handleRead(directory, initialAdd, wh, target, dir, depth, throttler) {
+    directory = sp.join(directory, "");
+    const throttleKey = target ? `${directory}:${target}` : directory;
+    throttler = this.fsw._throttle("readdir", throttleKey, 1e3);
+    if (!throttler)
+      return;
+    const previous = this.fsw._getWatchedDir(wh.path);
+    const current = /* @__PURE__ */ new Set();
+    let stream = this.fsw._readdirp(directory, {
+      fileFilter: (entry) => wh.filterPath(entry),
+      directoryFilter: (entry) => wh.filterDir(entry)
+    });
+    if (!stream)
+      return;
+    stream.on(STR_DATA, async (entry) => {
+      if (this.fsw.closed) {
+        stream = void 0;
+        return;
+      }
+      const item = entry.path;
+      let path8 = sp.join(directory, item);
+      current.add(item);
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path8, item)) {
+        return;
+      }
+      if (this.fsw.closed) {
+        stream = void 0;
+        return;
+      }
+      if (item === target || !target && !previous.has(item)) {
+        this.fsw._incrReadyCount();
+        path8 = sp.join(dir, sp.relative(dir, path8));
+        this._addToNodeFs(path8, initialAdd, wh, depth + 1);
+      }
+    }).on(EV.ERROR, this._boundHandleError);
+    return new Promise((resolve3, reject) => {
+      if (!stream)
+        return reject();
+      stream.once(STR_END, () => {
+        if (this.fsw.closed) {
+          stream = void 0;
+          return;
+        }
+        const wasThrottled = throttler ? throttler.clear() : false;
+        resolve3(void 0);
+        previous.getChildren().filter((item) => {
+          return item !== directory && !current.has(item);
+        }).forEach((item) => {
+          this.fsw._remove(directory, item);
+        });
+        stream = void 0;
+        if (wasThrottled)
+          this._handleRead(directory, false, wh, target, dir, depth, throttler);
+      });
+    });
+  }
+  /**
+   * Read directory to add / remove files from `@watched` list and re-read it on change.
+   * @param dir fs path
+   * @param stats
+   * @param initialAdd
+   * @param depth relative to user-supplied path
+   * @param target child path targeted for watch
+   * @param wh Common watch helpers for this path
+   * @param realpath
+   * @returns closer for the watcher instance.
+   */
+  async _handleDir(dir, stats, initialAdd, depth, target, wh, realpath2) {
+    const parentDir = this.fsw._getWatchedDir(sp.dirname(dir));
+    const tracked = parentDir.has(sp.basename(dir));
+    if (!(initialAdd && this.fsw.options.ignoreInitial) && !target && !tracked) {
+      this.fsw._emit(EV.ADD_DIR, dir, stats);
+    }
+    parentDir.add(sp.basename(dir));
+    this.fsw._getWatchedDir(dir);
+    let throttler;
+    let closer;
+    const oDepth = this.fsw.options.depth;
+    if ((oDepth == null || depth <= oDepth) && !this.fsw._symlinkPaths.has(realpath2)) {
+      if (!target) {
+        await this._handleRead(dir, initialAdd, wh, target, dir, depth, throttler);
+        if (this.fsw.closed)
+          return;
+      }
+      closer = this._watchWithNodeFs(dir, (dirPath, stats2) => {
+        if (stats2 && stats2.mtimeMs === 0)
+          return;
+        this._handleRead(dirPath, false, wh, target, dir, depth, throttler);
+      });
+    }
+    return closer;
+  }
+  /**
+   * Handle added file, directory, or glob pattern.
+   * Delegates call to _handleFile / _handleDir after checks.
+   * @param path to file or ir
+   * @param initialAdd was the file added at watch instantiation?
+   * @param priorWh depth relative to user-supplied path
+   * @param depth Child path actually targeted for watch
+   * @param target Child path actually targeted for watch
+   */
+  async _addToNodeFs(path8, initialAdd, priorWh, depth, target) {
+    const ready = this.fsw._emitReady;
+    if (this.fsw._isIgnored(path8) || this.fsw.closed) {
+      ready();
+      return false;
+    }
+    const wh = this.fsw._getWatchHelpers(path8);
+    if (priorWh) {
+      wh.filterPath = (entry) => priorWh.filterPath(entry);
+      wh.filterDir = (entry) => priorWh.filterDir(entry);
+    }
+    try {
+      const stats = await statMethods[wh.statMethod](wh.watchPath);
+      if (this.fsw.closed)
+        return;
+      if (this.fsw._isIgnored(wh.watchPath, stats)) {
+        ready();
+        return false;
+      }
+      const follow = this.fsw.options.followSymlinks;
+      let closer;
+      if (stats.isDirectory()) {
+        const absPath = sp.resolve(path8);
+        const targetPath = follow ? await fsrealpath(path8) : path8;
+        if (this.fsw.closed)
+          return;
+        closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
+        if (this.fsw.closed)
+          return;
+        if (absPath !== targetPath && targetPath !== void 0) {
+          this.fsw._symlinkPaths.set(absPath, targetPath);
+        }
+      } else if (stats.isSymbolicLink()) {
+        const targetPath = follow ? await fsrealpath(path8) : path8;
+        if (this.fsw.closed)
+          return;
+        const parent = sp.dirname(wh.watchPath);
+        this.fsw._getWatchedDir(parent).add(wh.watchPath);
+        this.fsw._emit(EV.ADD, wh.watchPath, stats);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path8, wh, targetPath);
+        if (this.fsw.closed)
+          return;
+        if (targetPath !== void 0) {
+          this.fsw._symlinkPaths.set(sp.resolve(path8), targetPath);
+        }
+      } else {
+        closer = this._handleFile(wh.watchPath, stats, initialAdd);
+      }
+      ready();
+      if (closer)
+        this.fsw._addPathCloser(path8, closer);
+      return false;
+    } catch (error) {
+      if (this.fsw._handleError(error)) {
+        ready();
+        return path8;
+      }
+    }
+  }
+};
+
+// node_modules/chokidar/index.js
+var SLASH = "/";
+var SLASH_SLASH = "//";
+var ONE_DOT = ".";
+var TWO_DOTS = "..";
+var STRING_TYPE = "string";
+var BACK_SLASH_RE = /\\/g;
+var DOUBLE_SLASH_RE = /\/\//g;
+var DOT_RE = /\..*\.(sw[px])$|~$|\.subl.*\.tmp/;
+var REPLACER_RE = /^\.[/\\]/;
+function arrify(item) {
+  return Array.isArray(item) ? item : [item];
+}
+var isMatcherObject = (matcher) => typeof matcher === "object" && matcher !== null && !(matcher instanceof RegExp);
+function createPattern(matcher) {
+  if (typeof matcher === "function")
+    return matcher;
+  if (typeof matcher === "string")
+    return (string) => matcher === string;
+  if (matcher instanceof RegExp)
+    return (string) => matcher.test(string);
+  if (typeof matcher === "object" && matcher !== null) {
+    return (string) => {
+      if (matcher.path === string)
+        return true;
+      if (matcher.recursive) {
+        const relative3 = sp2.relative(matcher.path, string);
+        if (!relative3) {
+          return false;
+        }
+        return !relative3.startsWith("..") && !sp2.isAbsolute(relative3);
+      }
+      return false;
+    };
+  }
+  return () => false;
+}
+function normalizePath(path8) {
+  if (typeof path8 !== "string")
+    throw new Error("string expected");
+  path8 = sp2.normalize(path8);
+  path8 = path8.replace(/\\/g, "/");
+  let prepend = false;
+  if (path8.startsWith("//"))
+    prepend = true;
+  path8 = path8.replace(DOUBLE_SLASH_RE, "/");
+  if (prepend)
+    path8 = "/" + path8;
+  return path8;
+}
+function matchPatterns(patterns, testString, stats) {
+  const path8 = normalizePath(testString);
+  for (let index = 0; index < patterns.length; index++) {
+    const pattern = patterns[index];
+    if (pattern(path8, stats)) {
+      return true;
+    }
+  }
+  return false;
+}
+function anymatch(matchers, testString) {
+  if (matchers == null) {
+    throw new TypeError("anymatch: specify first argument");
+  }
+  const matchersArray = arrify(matchers);
+  const patterns = matchersArray.map((matcher) => createPattern(matcher));
+  if (testString == null) {
+    return (testString2, stats) => {
+      return matchPatterns(patterns, testString2, stats);
+    };
+  }
+  return matchPatterns(patterns, testString);
+}
+var unifyPaths = (paths_) => {
+  const paths = arrify(paths_).flat();
+  if (!paths.every((p) => typeof p === STRING_TYPE)) {
+    throw new TypeError(`Non-string provided as watch path: ${paths}`);
+  }
+  return paths.map(normalizePathToUnix);
+};
+var toUnix = (string) => {
+  let str = string.replace(BACK_SLASH_RE, SLASH);
+  let prepend = false;
+  if (str.startsWith(SLASH_SLASH)) {
+    prepend = true;
+  }
+  str = str.replace(DOUBLE_SLASH_RE, SLASH);
+  if (prepend) {
+    str = SLASH + str;
+  }
+  return str;
+};
+var normalizePathToUnix = (path8) => toUnix(sp2.normalize(toUnix(path8)));
+var normalizeIgnored = (cwd = "") => (path8) => {
+  if (typeof path8 === "string") {
+    return normalizePathToUnix(sp2.isAbsolute(path8) ? path8 : sp2.join(cwd, path8));
+  } else {
+    return path8;
+  }
+};
+var getAbsolutePath = (path8, cwd) => {
+  if (sp2.isAbsolute(path8)) {
+    return path8;
+  }
+  return sp2.join(cwd, path8);
+};
+var EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
+var DirEntry = class {
+  path;
+  _removeWatcher;
+  items;
+  constructor(dir, removeWatcher) {
+    this.path = dir;
+    this._removeWatcher = removeWatcher;
+    this.items = /* @__PURE__ */ new Set();
+  }
+  add(item) {
+    const { items } = this;
+    if (!items)
+      return;
+    if (item !== ONE_DOT && item !== TWO_DOTS)
+      items.add(item);
+  }
+  async remove(item) {
+    const { items } = this;
+    if (!items)
+      return;
+    items.delete(item);
+    if (items.size > 0)
+      return;
+    const dir = this.path;
+    try {
+      await readdir2(dir);
+    } catch (err) {
+      if (this._removeWatcher) {
+        this._removeWatcher(sp2.dirname(dir), sp2.basename(dir));
+      }
+    }
+  }
+  has(item) {
+    const { items } = this;
+    if (!items)
+      return;
+    return items.has(item);
+  }
+  getChildren() {
+    const { items } = this;
+    if (!items)
+      return [];
+    return [...items.values()];
+  }
+  dispose() {
+    this.items.clear();
+    this.path = "";
+    this._removeWatcher = EMPTY_FN;
+    this.items = EMPTY_SET;
+    Object.freeze(this);
+  }
+};
+var STAT_METHOD_F = "stat";
+var STAT_METHOD_L = "lstat";
+var WatchHelper = class {
+  fsw;
+  path;
+  watchPath;
+  fullWatchPath;
+  dirParts;
+  followSymlinks;
+  statMethod;
+  constructor(path8, follow, fsw) {
+    this.fsw = fsw;
+    const watchPath = path8;
+    this.path = path8 = path8.replace(REPLACER_RE, "");
+    this.watchPath = watchPath;
+    this.fullWatchPath = sp2.resolve(watchPath);
+    this.dirParts = [];
+    this.dirParts.forEach((parts) => {
+      if (parts.length > 1)
+        parts.pop();
+    });
+    this.followSymlinks = follow;
+    this.statMethod = follow ? STAT_METHOD_F : STAT_METHOD_L;
+  }
+  entryPath(entry) {
+    return sp2.join(this.watchPath, sp2.relative(this.watchPath, entry.fullPath));
+  }
+  filterPath(entry) {
+    const { stats } = entry;
+    if (stats && stats.isSymbolicLink())
+      return this.filterDir(entry);
+    const resolvedPath = this.entryPath(entry);
+    return this.fsw._isntIgnored(resolvedPath, stats) && this.fsw._hasReadPermissions(stats);
+  }
+  filterDir(entry) {
+    return this.fsw._isntIgnored(this.entryPath(entry), entry.stats);
+  }
+};
+var FSWatcher = class extends EventEmitter {
+  closed;
+  options;
+  _closers;
+  _ignoredPaths;
+  _throttled;
+  _streams;
+  _symlinkPaths;
+  _watched;
+  _pendingWrites;
+  _pendingUnlinks;
+  _readyCount;
+  _emitReady;
+  _closePromise;
+  _userIgnored;
+  _readyEmitted;
+  _emitRaw;
+  _boundRemove;
+  _nodeFsHandler;
+  // Not indenting methods for history sake; for now.
+  constructor(_opts = {}) {
+    super();
+    this.closed = false;
+    this._closers = /* @__PURE__ */ new Map();
+    this._ignoredPaths = /* @__PURE__ */ new Set();
+    this._throttled = /* @__PURE__ */ new Map();
+    this._streams = /* @__PURE__ */ new Set();
+    this._symlinkPaths = /* @__PURE__ */ new Map();
+    this._watched = /* @__PURE__ */ new Map();
+    this._pendingWrites = /* @__PURE__ */ new Map();
+    this._pendingUnlinks = /* @__PURE__ */ new Map();
+    this._readyCount = 0;
+    this._readyEmitted = false;
+    const awf = _opts.awaitWriteFinish;
+    const DEF_AWF = { stabilityThreshold: 2e3, pollInterval: 100 };
+    const opts = {
+      // Defaults
+      persistent: true,
+      ignoreInitial: false,
+      ignorePermissionErrors: false,
+      interval: 100,
+      binaryInterval: 300,
+      followSymlinks: true,
+      usePolling: false,
+      // useAsync: false,
+      atomic: true,
+      // NOTE: overwritten later (depends on usePolling)
+      ..._opts,
+      // Change format
+      ignored: _opts.ignored ? arrify(_opts.ignored) : arrify([]),
+      awaitWriteFinish: awf === true ? DEF_AWF : typeof awf === "object" ? { ...DEF_AWF, ...awf } : false
+    };
+    if (isIBMi)
+      opts.usePolling = true;
+    if (opts.atomic === void 0)
+      opts.atomic = !opts.usePolling;
+    const envPoll = process.env.CHOKIDAR_USEPOLLING;
+    if (envPoll !== void 0) {
+      const envLower = envPoll.toLowerCase();
+      if (envLower === "false" || envLower === "0")
+        opts.usePolling = false;
+      else if (envLower === "true" || envLower === "1")
+        opts.usePolling = true;
+      else
+        opts.usePolling = !!envLower;
+    }
+    const envInterval = process.env.CHOKIDAR_INTERVAL;
+    if (envInterval)
+      opts.interval = Number.parseInt(envInterval, 10);
+    let readyCalls = 0;
+    this._emitReady = () => {
+      readyCalls++;
+      if (readyCalls >= this._readyCount) {
+        this._emitReady = EMPTY_FN;
+        this._readyEmitted = true;
+        process.nextTick(() => this.emit(EVENTS.READY));
+      }
+    };
+    this._emitRaw = (...args) => this.emit(EVENTS.RAW, ...args);
+    this._boundRemove = this._remove.bind(this);
+    this.options = opts;
+    this._nodeFsHandler = new NodeFsHandler(this);
+    Object.freeze(opts);
+  }
+  _addIgnoredPath(matcher) {
+    if (isMatcherObject(matcher)) {
+      for (const ignored of this._ignoredPaths) {
+        if (isMatcherObject(ignored) && ignored.path === matcher.path && ignored.recursive === matcher.recursive) {
+          return;
+        }
+      }
+    }
+    this._ignoredPaths.add(matcher);
+  }
+  _removeIgnoredPath(matcher) {
+    this._ignoredPaths.delete(matcher);
+    if (typeof matcher === "string") {
+      for (const ignored of this._ignoredPaths) {
+        if (isMatcherObject(ignored) && ignored.path === matcher) {
+          this._ignoredPaths.delete(ignored);
+        }
+      }
+    }
+  }
+  // Public methods
+  /**
+   * Adds paths to be watched on an existing FSWatcher instance.
+   * @param paths_ file or file list. Other arguments are unused
+   */
+  add(paths_, _origAdd, _internal) {
+    const { cwd } = this.options;
+    this.closed = false;
+    this._closePromise = void 0;
+    let paths = unifyPaths(paths_);
+    if (cwd) {
+      paths = paths.map((path8) => {
+        const absPath = getAbsolutePath(path8, cwd);
+        return absPath;
+      });
+    }
+    paths.forEach((path8) => {
+      this._removeIgnoredPath(path8);
+    });
+    this._userIgnored = void 0;
+    if (!this._readyCount)
+      this._readyCount = 0;
+    this._readyCount += paths.length;
+    Promise.all(paths.map(async (path8) => {
+      const res = await this._nodeFsHandler._addToNodeFs(path8, !_internal, void 0, 0, _origAdd);
+      if (res)
+        this._emitReady();
+      return res;
+    })).then((results) => {
+      if (this.closed)
+        return;
+      results.forEach((item) => {
+        if (item)
+          this.add(sp2.dirname(item), sp2.basename(_origAdd || item));
+      });
+    });
+    return this;
+  }
+  /**
+   * Close watchers or start ignoring events from specified paths.
+   */
+  unwatch(paths_) {
+    if (this.closed)
+      return this;
+    const paths = unifyPaths(paths_);
+    const { cwd } = this.options;
+    paths.forEach((path8) => {
+      if (!sp2.isAbsolute(path8) && !this._closers.has(path8)) {
+        if (cwd)
+          path8 = sp2.join(cwd, path8);
+        path8 = sp2.resolve(path8);
+      }
+      this._closePath(path8);
+      this._addIgnoredPath(path8);
+      if (this._watched.has(path8)) {
+        this._addIgnoredPath({
+          path: path8,
+          recursive: true
+        });
+      }
+      this._userIgnored = void 0;
+    });
+    return this;
+  }
+  /**
+   * Close watchers and remove all listeners from watched paths.
+   */
+  close() {
+    if (this._closePromise) {
+      return this._closePromise;
+    }
+    this.closed = true;
+    this.removeAllListeners();
+    const closers = [];
+    this._closers.forEach((closerList) => closerList.forEach((closer) => {
+      const promise = closer();
+      if (promise instanceof Promise)
+        closers.push(promise);
+    }));
+    this._streams.forEach((stream) => stream.destroy());
+    this._userIgnored = void 0;
+    this._readyCount = 0;
+    this._readyEmitted = false;
+    this._watched.forEach((dirent) => dirent.dispose());
+    this._closers.clear();
+    this._watched.clear();
+    this._streams.clear();
+    this._symlinkPaths.clear();
+    this._throttled.clear();
+    this._closePromise = closers.length ? Promise.all(closers).then(() => void 0) : Promise.resolve();
+    return this._closePromise;
+  }
+  /**
+   * Expose list of watched paths
+   * @returns for chaining
+   */
+  getWatched() {
+    const watchList = {};
+    this._watched.forEach((entry, dir) => {
+      const key = this.options.cwd ? sp2.relative(this.options.cwd, dir) : dir;
+      const index = key || ONE_DOT;
+      watchList[index] = entry.getChildren().sort();
+    });
+    return watchList;
+  }
+  emitWithAll(event, args) {
+    this.emit(event, ...args);
+    if (event !== EVENTS.ERROR)
+      this.emit(EVENTS.ALL, event, ...args);
+  }
+  // Common helpers
+  // --------------
+  /**
+   * Normalize and emit events.
+   * Calling _emit DOES NOT MEAN emit() would be called!
+   * @param event Type of event
+   * @param path File or directory path
+   * @param stats arguments to be passed with event
+   * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
+   */
+  async _emit(event, path8, stats) {
+    if (this.closed)
+      return;
+    const opts = this.options;
+    if (isWindows)
+      path8 = sp2.normalize(path8);
+    if (opts.cwd)
+      path8 = sp2.relative(opts.cwd, path8);
+    const args = [path8];
+    if (stats != null)
+      args.push(stats);
+    const awf = opts.awaitWriteFinish;
+    let pw;
+    if (awf && (pw = this._pendingWrites.get(path8))) {
+      pw.lastChange = /* @__PURE__ */ new Date();
+      return this;
+    }
+    if (opts.atomic) {
+      if (event === EVENTS.UNLINK) {
+        this._pendingUnlinks.set(path8, [event, ...args]);
+        setTimeout(() => {
+          this._pendingUnlinks.forEach((entry, path9) => {
+            this.emit(...entry);
+            this.emit(EVENTS.ALL, ...entry);
+            this._pendingUnlinks.delete(path9);
+          });
+        }, typeof opts.atomic === "number" ? opts.atomic : 100);
+        return this;
+      }
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path8)) {
+        event = EVENTS.CHANGE;
+        this._pendingUnlinks.delete(path8);
+      }
+    }
+    if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
+      const awfEmit = (err, stats2) => {
+        if (err) {
+          event = EVENTS.ERROR;
+          args[0] = err;
+          this.emitWithAll(event, args);
+        } else if (stats2) {
+          if (args.length > 1) {
+            args[1] = stats2;
+          } else {
+            args.push(stats2);
+          }
+          this.emitWithAll(event, args);
+        }
+      };
+      this._awaitWriteFinish(path8, awf.stabilityThreshold, event, awfEmit);
+      return this;
+    }
+    if (event === EVENTS.CHANGE) {
+      const isThrottled = !this._throttle(EVENTS.CHANGE, path8, 50);
+      if (isThrottled)
+        return this;
+    }
+    if (opts.alwaysStat && stats === void 0 && (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
+      const fullPath = opts.cwd ? sp2.join(opts.cwd, path8) : path8;
+      let stats2;
+      try {
+        stats2 = await stat3(fullPath);
+      } catch (err) {
+      }
+      if (!stats2 || this.closed)
+        return;
+      args.push(stats2);
+    }
+    this.emitWithAll(event, args);
+    return this;
+  }
+  /**
+   * Common handler for errors
+   * @returns The error if defined, otherwise the value of the FSWatcher instance's `closed` flag
+   */
+  _handleError(error) {
+    const code = error && error.code;
+    if (error && code !== "ENOENT" && code !== "ENOTDIR" && (!this.options.ignorePermissionErrors || code !== "EPERM" && code !== "EACCES")) {
+      this.emit(EVENTS.ERROR, error);
+    }
+    return error || this.closed;
+  }
+  /**
+   * Helper utility for throttling
+   * @param actionType type being throttled
+   * @param path being acted upon
+   * @param timeout duration of time to suppress duplicate actions
+   * @returns tracking object or false if action should be suppressed
+   */
+  _throttle(actionType, path8, timeout) {
+    if (!this._throttled.has(actionType)) {
+      this._throttled.set(actionType, /* @__PURE__ */ new Map());
+    }
+    const action = this._throttled.get(actionType);
+    if (!action)
+      throw new Error("invalid throttle");
+    const actionPath = action.get(path8);
+    if (actionPath) {
+      actionPath.count++;
+      return false;
+    }
+    let timeoutObject;
+    const clear = () => {
+      const item = action.get(path8);
+      const count = item ? item.count : 0;
+      action.delete(path8);
+      clearTimeout(timeoutObject);
+      if (item)
+        clearTimeout(item.timeoutObject);
+      return count;
+    };
+    timeoutObject = setTimeout(clear, timeout);
+    const thr = { timeoutObject, clear, count: 0 };
+    action.set(path8, thr);
+    return thr;
+  }
+  _incrReadyCount() {
+    return this._readyCount++;
+  }
+  /**
+   * Awaits write operation to finish.
+   * Polls a newly created file for size variations. When files size does not change for 'threshold' milliseconds calls callback.
+   * @param path being acted upon
+   * @param threshold Time in milliseconds a file size must be fixed before acknowledging write OP is finished
+   * @param event
+   * @param awfEmit Callback to be called when ready for event to be emitted.
+   */
+  _awaitWriteFinish(path8, threshold, event, awfEmit) {
+    const awf = this.options.awaitWriteFinish;
+    if (typeof awf !== "object")
+      return;
+    const pollInterval = awf.pollInterval;
+    let timeoutHandler;
+    let fullPath = path8;
+    if (this.options.cwd && !sp2.isAbsolute(path8)) {
+      fullPath = sp2.join(this.options.cwd, path8);
+    }
+    const now = /* @__PURE__ */ new Date();
+    const writes = this._pendingWrites;
+    function awaitWriteFinishFn(prevStat) {
+      statcb(fullPath, (err, curStat) => {
+        if (err || !writes.has(path8)) {
+          if (err && err.code !== "ENOENT")
+            awfEmit(err);
+          return;
+        }
+        const now2 = Number(/* @__PURE__ */ new Date());
+        if (prevStat && curStat.size !== prevStat.size) {
+          writes.get(path8).lastChange = now2;
+        }
+        const pw = writes.get(path8);
+        const df = now2 - pw.lastChange;
+        if (df >= threshold) {
+          writes.delete(path8);
+          awfEmit(void 0, curStat);
+        } else {
+          timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
+        }
+      });
+    }
+    if (!writes.has(path8)) {
+      writes.set(path8, {
+        lastChange: now,
+        cancelWait: () => {
+          writes.delete(path8);
+          clearTimeout(timeoutHandler);
+          return event;
+        }
+      });
+      timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval);
+    }
+  }
+  /**
+   * Determines whether user has asked to ignore this path.
+   */
+  _isIgnored(path8, stats) {
+    if (this.options.atomic && DOT_RE.test(path8))
+      return true;
+    if (!this._userIgnored) {
+      const { cwd } = this.options;
+      const ign = this.options.ignored;
+      const ignored = (ign || []).map(normalizeIgnored(cwd));
+      const ignoredPaths = [...this._ignoredPaths];
+      const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
+      this._userIgnored = anymatch(list, void 0);
+    }
+    return this._userIgnored(path8, stats);
+  }
+  _isntIgnored(path8, stat4) {
+    return !this._isIgnored(path8, stat4);
+  }
+  /**
+   * Provides a set of common helpers and properties relating to symlink handling.
+   * @param path file or directory pattern being watched
+   */
+  _getWatchHelpers(path8) {
+    return new WatchHelper(path8, this.options.followSymlinks, this);
+  }
+  // Directory helpers
+  // -----------------
+  /**
+   * Provides directory tracking objects
+   * @param directory path of the directory
+   */
+  _getWatchedDir(directory) {
+    const dir = sp2.resolve(directory);
+    if (!this._watched.has(dir))
+      this._watched.set(dir, new DirEntry(dir, this._boundRemove));
+    return this._watched.get(dir);
+  }
+  // File helpers
+  // ------------
+  /**
+   * Check for read permissions: https://stackoverflow.com/a/11781404/1358405
+   */
+  _hasReadPermissions(stats) {
+    if (this.options.ignorePermissionErrors)
+      return true;
+    return Boolean(Number(stats.mode) & 256);
+  }
+  /**
+   * Handles emitting unlink events for
+   * files and directories, and via recursion, for
+   * files and directories within directories that are unlinked
+   * @param directory within which the following item is located
+   * @param item      base path of item/directory
+   */
+  _remove(directory, item, isDirectory) {
+    const path8 = sp2.join(directory, item);
+    const fullPath = sp2.resolve(path8);
+    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path8) || this._watched.has(fullPath);
+    if (!this._throttle("remove", path8, 100))
+      return;
+    if (!isDirectory && this._watched.size === 1) {
+      this.add(directory, item, true);
+    }
+    const wp = this._getWatchedDir(path8);
+    const nestedDirectoryChildren = wp.getChildren();
+    nestedDirectoryChildren.forEach((nested) => this._remove(path8, nested));
+    const parent = this._getWatchedDir(directory);
+    const wasTracked = parent.has(item);
+    parent.remove(item);
+    if (this._symlinkPaths.has(fullPath)) {
+      this._symlinkPaths.delete(fullPath);
+    }
+    let relPath = path8;
+    if (this.options.cwd)
+      relPath = sp2.relative(this.options.cwd, path8);
+    if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
+      const event = this._pendingWrites.get(relPath).cancelWait();
+      if (event === EVENTS.ADD)
+        return;
+    }
+    this._watched.delete(path8);
+    this._watched.delete(fullPath);
+    const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
+    if (wasTracked && !this._isIgnored(path8))
+      this._emit(eventName, path8);
+    this._closePath(path8);
+  }
+  /**
+   * Closes all watchers for a path
+   */
+  _closePath(path8) {
+    this._closeFile(path8);
+    const dir = sp2.dirname(path8);
+    this._getWatchedDir(dir).remove(sp2.basename(path8));
+  }
+  /**
+   * Closes only file-specific watchers
+   */
+  _closeFile(path8) {
+    const closers = this._closers.get(path8);
+    if (!closers)
+      return;
+    closers.forEach((closer) => closer());
+    this._closers.delete(path8);
+  }
+  _addPathCloser(path8, closer) {
+    if (!closer)
+      return;
+    let list = this._closers.get(path8);
+    if (!list) {
+      list = [];
+      this._closers.set(path8, list);
+    }
+    list.push(closer);
+  }
+  _readdirp(root, opts) {
+    if (this.closed)
+      return;
+    const options = { type: EVENTS.ALL, alwaysStat: true, lstat: true, ...opts, depth: 0 };
+    let stream = readdirp(root, options);
+    this._streams.add(stream);
+    stream.once(STR_CLOSE, () => {
+      stream = void 0;
+    });
+    stream.once(STR_END, () => {
+      if (stream) {
+        this._streams.delete(stream);
+        stream = void 0;
+      }
+    });
+    return stream;
+  }
+};
+function watch(paths, options = {}) {
+  const watcher = new FSWatcher(options);
+  watcher.add(paths);
+  return watcher;
+}
+
+// src/daemon/watcher.ts
+import path4 from "path";
+var PlanWatcher = class {
+  config;
+  fsWatcher = null;
+  knownPlans = /* @__PURE__ */ new Set();
+  constructor(config) {
+    this.config = config;
+  }
+  checkToolEvent(event) {
+    if (event.tool_name === "EnterPlanMode" || event.tool_name === "ExitPlanMode") {
+      this.config.onPlan({
+        source: "hook",
+        sessionId: event.session_id,
+        detail: `Plan mode ${event.tool_name === "EnterPlanMode" ? "entered" : "exited"}`,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      return;
+    }
+    if (["Write", "Edit", "Read"].includes(event.tool_name) && event.tool_input) {
+      const filePath = event.tool_input.file_path ?? event.tool_input.path;
+      if (filePath && this.isInPlanDirectory(filePath)) {
+        this.knownPlans.add(filePath);
+        this.config.onPlan({
+          source: "tool",
+          filePath,
+          sessionId: event.session_id,
+          detail: `${event.tool_name} on plan file: ${path4.basename(filePath)}`,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      }
+    }
+  }
+  startFileWatcher() {
+    const absPaths = this.config.watchPaths.map(
+      (p) => path4.resolve(this.config.projectRoot, p)
+    );
+    this.fsWatcher = watch(absPaths, {
+      ignoreInitial: true,
+      persistent: true,
+      depth: 3,
+      awaitWriteFinish: { stabilityThreshold: FILE_WATCH_STABILITY_MS }
+    });
+    this.fsWatcher.on("add", (fp) => this.onFileChange(fp, "created"));
+    this.fsWatcher.on("change", (fp) => this.onFileChange(fp, "modified"));
+  }
+  stopFileWatcher() {
+    this.fsWatcher?.close();
+    this.fsWatcher = null;
+  }
+  onFileChange(absolutePath, action) {
+    const rel = path4.relative(this.config.projectRoot, absolutePath);
+    this.knownPlans.add(absolutePath);
+    this.config.onPlan({
+      source: "filesystem",
+      filePath: absolutePath,
+      detail: `Plan file ${action}: ${rel}`,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  isInPlanDirectory(filePath) {
+    const abs = path4.isAbsolute(filePath) ? filePath : path4.resolve(this.config.projectRoot, filePath);
+    return this.config.watchPaths.some(
+      (wp) => abs.startsWith(path4.resolve(this.config.projectRoot, wp))
+    );
+  }
+};
+
+// src/capture/transcript-miner.ts
+var TranscriptMiner = class {
+  registry;
+  constructor(config) {
+    this.registry = new AgentRegistry(config?.additionalAdapters);
+  }
+  /**
+   * Extract all conversation turns for a session.
+   * Convenience wrapper — delegates to getAllTurnsWithSource.
+   */
+  getAllTurns(sessionId) {
+    return this.getAllTurnsWithSource(sessionId).turns;
+  }
+  /**
+   * Extract turns using the hook-provided transcript path first (fast, no scanning),
+   * then fall back to adapter registry scanning if the path isn't provided.
+   */
+  getAllTurnsWithSource(sessionId, transcriptPath) {
+    if (transcriptPath) {
+      const result2 = this.registry.parseTurnsFromPath(transcriptPath);
+      if (result2) return result2;
+    }
+    const result = this.registry.getTranscriptTurns(sessionId);
+    if (result) return result;
+    return { turns: [], source: "none" };
+  }
+};
+function extractTurnsFromBuffer(events) {
+  const turns = [];
+  let current = null;
+  for (const event of events) {
+    const type = event.type;
+    if (type === "user_prompt") {
+      if (current) turns.push(current);
+      current = {
+        prompt: String(event.prompt ?? "").slice(0, PROMPT_PREVIEW_CHARS),
+        toolCount: 0,
+        timestamp: String(event.timestamp ?? (/* @__PURE__ */ new Date()).toISOString())
+      };
+    } else if (type === "tool_use") {
+      if (current) current.toolCount++;
+    }
+  }
+  if (current) turns.push(current);
+  return turns;
+}
+
+// src/vault/observations.ts
+function writeObservationNotes(observations, sessionId, writer, index, vaultDir) {
+  const results = [];
+  for (const obs of observations) {
+    const obsId = `${obs.type}-${sessionId.slice(-6)}-${Date.now()}`;
+    const body = formatMemoryBody({
+      title: obs.title,
+      observationType: obs.type,
+      content: obs.content,
+      sessionId,
+      root_cause: obs.root_cause,
+      fix: obs.fix,
+      rationale: obs.rationale,
+      alternatives_rejected: obs.alternatives_rejected,
+      gained: obs.gained,
+      sacrificed: obs.sacrificed,
+      tags: obs.tags
+    });
+    const relativePath = writer.writeMemory({
+      id: obsId,
+      observation_type: obs.type,
+      session: sessionNoteId(sessionId),
+      tags: obs.tags,
+      content: body
+    });
+    indexNote(index, vaultDir, relativePath);
+    results.push({ id: obsId, path: relativePath, observation: obs });
+  }
+  return results;
+}
+
+// src/artifacts/candidates.ts
+import { execFileSync } from "child_process";
+import fs4 from "fs";
+import path5 from "path";
+var EXCLUDED_FILENAMES = /* @__PURE__ */ new Set([
+  "claude.md",
+  "agents.md",
+  "gemini.md",
+  "readme.md",
+  "contributing.md",
+  "changelog.md",
+  "license.md",
+  "pull_request_template.md"
+]);
+var EXCLUDED_PREFIXES = [
+  "commands/",
+  "skills/",
+  "hooks/",
+  ".claude-plugin/",
+  ".cursor-plugin/",
+  ".claude/",
+  ".github/"
+];
+function isExcludedPath(relativePath) {
+  const basename3 = path5.basename(relativePath).toLowerCase();
+  if (EXCLUDED_FILENAMES.has(basename3)) return true;
+  const normalized = relativePath.replace(/\\/g, "/");
+  return EXCLUDED_PREFIXES.some((prefix) => normalized.startsWith(prefix));
+}
+function collectArtifactCandidates(filePaths, config, projectRoot) {
+  if (filePaths.size === 0) return [];
+  const extFiltered = [...filePaths].filter(
+    (absPath) => config.artifact_extensions.includes(path5.extname(absPath))
+  );
+  if (extFiltered.length === 0) return [];
+  const ignoredSet = getGitIgnored(extFiltered, projectRoot);
+  const candidates = [];
+  for (const absPath of extFiltered) {
+    if (ignoredSet.has(absPath)) continue;
+    try {
+      const content = fs4.readFileSync(absPath, "utf-8");
+      const relativePath = path5.relative(projectRoot, absPath);
+      if (isExcludedPath(relativePath)) continue;
+      candidates.push({ path: relativePath, content });
+    } catch {
+    }
+  }
+  return candidates;
+}
+function getGitIgnored(filePaths, cwd) {
+  try {
+    const result = execFileSync("git", ["check-ignore", ...filePaths], {
+      cwd,
+      stdio: ["pipe", "pipe", "pipe"],
+      encoding: "utf-8"
+    });
+    return new Set(result.trim().split("\n").filter(Boolean));
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+
+// src/artifacts/slugify.ts
+import crypto from "crypto";
+import path6 from "path";
+function slugifyPath(relativePath) {
+  const ext = path6.extname(relativePath);
+  const withoutExt = ext ? relativePath.slice(0, -ext.length) : relativePath;
+  let slug = withoutExt.replace(/[/\\]/g, "-").toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "");
+  if (slug.length > MAX_SLUG_LENGTH) {
+    const hash = crypto.createHash("sha256").update(relativePath).digest("hex").slice(0, 6);
+    slug = slug.slice(0, MAX_SLUG_LENGTH) + "-" + hash;
+  }
+  return slug;
+}
+
+// src/daemon/main.ts
+var import_yaml = __toESM(require_dist(), 1);
+import fs5 from "fs";
+import path7 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+function indexAndEmbed(relativePath, noteId, embeddingText, metadata, deps) {
+  indexNote(deps.index, deps.vaultDir, relativePath);
+  if (deps.vectorIndex && embeddingText) {
+    generateEmbedding(deps.embeddingProvider, embeddingText.slice(0, EMBEDDING_INPUT_LIMIT)).then((emb) => deps.vectorIndex.upsert(noteId, emb.embedding, metadata)).catch((err) => deps.logger.debug("embeddings", "Embedding failed", { id: noteId, error: err.message }));
+  }
+}
+function writeObservations(observations, sessionId, deps) {
+  const written = writeObservationNotes(observations, sessionId, deps.vault, deps.index, deps.vaultDir);
+  for (const note of written) {
+    indexAndEmbed(
+      note.path,
+      note.id,
+      `${note.observation.title}
+${note.observation.content}`,
+      { type: "memory", importance: "high", session_id: sessionId },
+      deps
+    );
+    deps.logger.info("processor", "Observation written", { type: note.observation.type, title: note.observation.title, session_id: sessionId });
+  }
+}
+async function captureArtifacts(candidates, classified, sessionId, deps, lineage) {
+  const candidateMap = new Map(candidates.map((c) => [c.path, c]));
+  for (const artifact of classified) {
+    const candidate = candidateMap.get(artifact.source_path);
+    if (!candidate) continue;
+    const artifactId = slugifyPath(artifact.source_path);
+    const artifactPath = deps.vault.writeArtifact({
+      id: artifactId,
+      artifact_type: artifact.artifact_type,
+      source_path: artifact.source_path,
+      title: artifact.title,
+      session: sessionId,
+      tags: artifact.tags,
+      content: candidate.content
+    });
+    indexAndEmbed(
+      artifactPath,
+      artifactId,
+      `${artifact.title}
+${candidate.content}`,
+      { type: "artifact", artifact_type: artifact.artifact_type, session_id: sessionId },
+      deps
+    );
+    deps.logger.info("processor", "Artifact captured", {
+      id: artifactId,
+      type: artifact.artifact_type,
+      source: artifact.source_path
+    });
+    lineage?.registerArtifactForSession(sessionId, artifactId);
+  }
+}
+function migrateMemoryFiles(vaultDir) {
+  const memoriesDir = path7.join(vaultDir, "memories");
+  if (!fs5.existsSync(memoriesDir)) return 0;
+  let moved = 0;
+  const entries = fs5.readdirSync(memoriesDir);
+  for (const entry of entries) {
+    const fullPath = path7.join(memoriesDir, entry);
+    if (!entry.endsWith(".md")) continue;
+    if (fs5.statSync(fullPath).isDirectory()) continue;
+    try {
+      const content = fs5.readFileSync(fullPath, "utf-8");
+      const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+      if (!fmMatch) continue;
+      const parsed = import_yaml.default.parse(fmMatch[1]);
+      const obsType = parsed.observation_type;
+      if (!obsType) continue;
+      const normalizedType = obsType.replace(/_/g, "-");
+      const targetDir = path7.join(memoriesDir, normalizedType);
+      fs5.mkdirSync(targetDir, { recursive: true });
+      const targetPath = path7.join(targetDir, entry);
+      fs5.renameSync(fullPath, targetPath);
+      const now = /* @__PURE__ */ new Date();
+      fs5.utimesSync(targetPath, now, now);
+      moved++;
+    } catch {
+    }
+  }
+  return moved;
+}
+async function main() {
+  const vaultArg = process.argv.find((_, i) => process.argv[i - 1] === "--vault");
+  if (!vaultArg) {
+    process.stderr.write("Usage: mycod --vault <path>\n");
+    process.exit(1);
+  }
+  const vaultDir = path7.resolve(vaultArg);
+  const config = loadConfig(vaultDir);
+  const logger = new DaemonLogger(path7.join(vaultDir, "logs"), {
+    level: config.daemon.log_level,
+    maxSize: config.daemon.max_log_size
+  });
+  const server = new DaemonServer({ vaultDir, logger });
+  const registry = new SessionRegistry({
+    gracePeriod: config.daemon.grace_period,
+    onEmpty: async () => {
+      logger.info("daemon", "Grace period expired, shutting down");
+      planWatcher.stopFileWatcher();
+      await server.stop();
+      vectorIndex?.close();
+      index.close();
+      logger.close();
+      process.exit(0);
+    }
+  });
+  const llmProvider = createLlmProvider(config.intelligence.llm);
+  const embeddingProvider = createEmbeddingProvider(config.intelligence.embedding);
+  let vectorIndex = null;
+  try {
+    const testEmbed = await embeddingProvider.embed("test");
+    vectorIndex = new VectorIndex(path7.join(vaultDir, "vectors.db"), testEmbed.dimensions);
+    logger.info("embeddings", "Vector index initialized", { dimensions: testEmbed.dimensions });
+  } catch (error) {
+    logger.warn("embeddings", "Vector index unavailable", { error: error.message });
+  }
+  const processor = new BufferProcessor(llmProvider, config.intelligence.llm.context_window);
+  const vault = new VaultWriter(vaultDir);
+  const index = new MycoIndex(path7.join(vaultDir, "index.db"));
+  const lineageGraph = new LineageGraph(vaultDir);
+  const transcriptMiner = new TranscriptMiner({
+    additionalAdapters: config.capture.transcript_paths.map(
+      (p) => createPerProjectAdapter(p, claudeCodeAdapter.parseTurns)
+    )
+  });
+  let activeStopProcessing = null;
+  const indexDeps = { index, vaultDir, vectorIndex, embeddingProvider, logger };
+  const bufferDir = path7.join(vaultDir, "buffer");
+  const sessionBuffers = /* @__PURE__ */ new Map();
+  const sessionFilePaths = /* @__PURE__ */ new Map();
+  if (fs5.existsSync(bufferDir)) {
+    const cutoff = Date.now() - STALE_BUFFER_MAX_AGE_MS;
+    for (const file of fs5.readdirSync(bufferDir)) {
+      const filePath = path7.join(bufferDir, file);
+      const stat4 = fs5.statSync(filePath);
+      if (stat4.mtimeMs < cutoff) {
+        fs5.unlinkSync(filePath);
+        logger.debug("daemon", "Cleaned stale buffer", { file });
+      }
+    }
+  }
+  const migrated = migrateMemoryFiles(vaultDir);
+  if (migrated > 0) {
+    logger.info("daemon", "Migrated memory files to type subdirectories", { count: migrated });
+    initFts(index);
+    rebuildIndex(index, vaultDir);
+  }
+  const RegisterBody = external_exports.object({
+    session_id: external_exports.string(),
+    branch: external_exports.string().optional(),
+    started_at: external_exports.string().optional()
+  });
+  const UnregisterBody = external_exports.object({ session_id: external_exports.string() });
+  const EventBody = external_exports.object({ type: external_exports.string(), session_id: external_exports.string() }).passthrough();
+  const StopBody = external_exports.object({
+    session_id: external_exports.string(),
+    user: external_exports.string().optional(),
+    transcript_path: external_exports.string().optional(),
+    last_assistant_message: external_exports.string().optional()
+  });
+  const ContextBody = external_exports.object({
+    session_id: external_exports.string().optional(),
+    branch: external_exports.string().optional(),
+    files: external_exports.array(external_exports.string()).optional()
+  });
+  const planWatcher = new PlanWatcher({
+    projectRoot: process.cwd(),
+    watchPaths: config.capture.artifact_watch,
+    onPlan: (event) => {
+      logger.info("watcher", "Plan detected", { source: event.source, file: event.filePath });
+      if (event.filePath) {
+        try {
+          const content = fs5.readFileSync(event.filePath, "utf-8");
+          const relativePath = path7.relative(vaultDir, event.filePath);
+          const title = content.match(/^#\s+(.+)$/m)?.[1] ?? path7.basename(event.filePath);
+          const planId = `plan-${path7.basename(event.filePath, ".md")}`;
+          indexAndEmbed(
+            relativePath,
+            planId,
+            `${title}
+${content}`,
+            { type: "plan" },
+            indexDeps
+          );
+          if (event.sessionId) {
+            lineageGraph.registerArtifactForSession(event.sessionId, planId);
+            logger.debug("lineage", "Plan registered for session", { planId, session: event.sessionId });
+          }
+          logger.info("watcher", "Plan indexed", { path: relativePath });
+        } catch (err) {
+          logger.debug("watcher", "Plan index failed", { error: err.message });
+        }
+      }
+    }
+  });
+  planWatcher.startFileWatcher();
+  const batchManager = new BatchManager(async (closedBatch) => {
+    if (closedBatch.length === 0) return;
+    const sessionId = closedBatch[0].session_id;
+    const asRecords = closedBatch;
+    const result = await processor.process(asRecords, sessionId);
+    if (!result.degraded) {
+      writeObservations(result.observations, sessionId, { vault, ...indexDeps });
+    }
+    logger.debug("processor", "Batch processed", {
+      session_id: sessionId,
+      events: closedBatch.length,
+      observations: result.observations.length,
+      degraded: result.degraded
+    });
+  });
+  server.registerRoute("POST", "/sessions/register", async (body) => {
+    const { session_id, branch, started_at } = RegisterBody.parse(body);
+    const resolvedStartedAt = started_at ?? (/* @__PURE__ */ new Date()).toISOString();
+    registry.register(session_id, { started_at: resolvedStartedAt, branch });
+    server.updateDaemonJsonSessions(registry.sessions);
+    try {
+      const recentSessions = index.query({ type: "session", limit: LINEAGE_RECENT_SESSIONS_LIMIT }).map((n) => {
+        const fm = n.frontmatter;
+        return { id: bareSessionId(n.id), ended: fm.ended, branch: fm.branch };
+      });
+      const activeSessions = registry.sessions.filter((s) => s !== session_id).map((s) => registry.getSession(s)).filter((s) => s !== void 0);
+      const link = lineageGraph.detectHeuristicParent(session_id, {
+        started_at: resolvedStartedAt,
+        branch
+      }, recentSessions, activeSessions);
+      if (link) {
+        logger.info("lineage", "Heuristic parent detected", { child: session_id, parent: link.parent, signal: link.signal });
+      }
+    } catch (err) {
+      logger.debug("lineage", "Heuristic detection failed", { error: err.message });
+    }
+    logger.info("lifecycle", "Session registered", { session_id, branch });
+    return { ok: true, sessions: registry.sessions };
+  });
+  server.registerRoute("POST", "/sessions/unregister", async (body) => {
+    const { session_id } = UnregisterBody.parse(body);
+    registry.unregister(session_id);
+    try {
+      const cutoff = Date.now() - STALE_BUFFER_MAX_AGE_MS;
+      for (const file of fs5.readdirSync(bufferDir)) {
+        if (!file.endsWith(".jsonl")) continue;
+        const bufferSessionId = file.replace(".jsonl", "");
+        if (bufferSessionId === session_id) continue;
+        const filePath = path7.join(bufferDir, file);
+        const stat4 = fs5.statSync(filePath);
+        if (stat4.mtimeMs < cutoff) {
+          fs5.unlinkSync(filePath);
+          logger.debug("daemon", "Cleaned stale buffer", { file });
+        }
+      }
+    } catch {
+    }
+    sessionBuffers.delete(session_id);
+    sessionFilePaths.delete(session_id);
+    server.updateDaemonJsonSessions(registry.sessions);
+    logger.info("lifecycle", "Session unregistered", { session_id });
+    return { ok: true, sessions: registry.sessions };
+  });
+  server.registerRoute("POST", "/events", async (body) => {
+    const validated = EventBody.parse(body);
+    const event = { ...validated, timestamp: validated.timestamp ?? (/* @__PURE__ */ new Date()).toISOString() };
+    logger.debug("hooks", "Event received", { type: event.type, session_id: event.session_id });
+    if (!registry.getSession(event.session_id)) {
+      registry.register(event.session_id, { started_at: event.timestamp });
+      logger.debug("lifecycle", "Auto-registered session from event", { session_id: event.session_id });
+    }
+    if (!sessionBuffers.has(event.session_id)) {
+      sessionBuffers.set(event.session_id, new EventBuffer(bufferDir, event.session_id));
+    }
+    sessionBuffers.get(event.session_id).append(event);
+    batchManager.addEvent(event);
+    if (validated.type === "tool_use") {
+      const v = validated;
+      planWatcher.checkToolEvent({ tool_name: String(v.tool_name ?? ""), tool_input: v.tool_input, session_id: validated.session_id });
+      const toolName = String(v.tool_name ?? "");
+      if (toolName === "Write" || toolName === "Edit") {
+        const filePath = v.tool_input?.file_path;
+        if (filePath) {
+          if (!sessionFilePaths.has(event.session_id)) {
+            sessionFilePaths.set(event.session_id, /* @__PURE__ */ new Set());
+          }
+          sessionFilePaths.get(event.session_id).add(filePath);
+        }
+      }
+    }
+    return { ok: true };
+  });
+  server.registerRoute("POST", "/events/stop", async (body) => {
+    const { session_id: sessionId, user, transcript_path: hookTranscriptPath, last_assistant_message: lastAssistantMessage } = StopBody.parse(body);
+    if (!registry.getSession(sessionId)) {
+      registry.register(sessionId, { started_at: (/* @__PURE__ */ new Date()).toISOString() });
+      logger.debug("lifecycle", "Auto-registered session from stop event", { session_id: sessionId });
+    }
+    const sessionMeta = registry.getSession(sessionId);
+    logger.info("hooks", "Stop received", { session_id: sessionId, has_transcript_path: !!hookTranscriptPath, has_response: !!lastAssistantMessage });
+    const run = () => processStopEvent(sessionId, user, sessionMeta, hookTranscriptPath, lastAssistantMessage).catch((err) => {
+      logger.error("processor", "Stop processing failed", { session_id: sessionId, error: err.message });
+    });
+    const prev = activeStopProcessing ?? Promise.resolve();
+    activeStopProcessing = prev.then(run).finally(() => {
+      activeStopProcessing = null;
+    });
+    return { ok: true };
+  });
+  async function processStopEvent(sessionId, user, sessionMeta, hookTranscriptPath, lastAssistantMessage) {
+    const lastBatch = batchManager.finalize(sessionId);
+    const transcriptResult = transcriptMiner.getAllTurnsWithSource(sessionId, hookTranscriptPath);
+    let allTurns = transcriptResult.turns;
+    let turnSource = transcriptResult.source;
+    const bufferEvents = sessionBuffers.get(sessionId)?.readAll() ?? [];
+    if (allTurns.length === 0) {
+      allTurns = extractTurnsFromBuffer(bufferEvents);
+      turnSource = "buffer";
+    } else if (bufferEvents.length > 0) {
+      const lastTranscriptTs = allTurns[allTurns.length - 1].timestamp;
+      if (lastTranscriptTs) {
+        const newerEvents = bufferEvents.filter(
+          (e) => String(e.timestamp ?? "") > lastTranscriptTs
+        );
+        if (newerEvents.length > 0) {
+          const bufferTurns = extractTurnsFromBuffer(newerEvents);
+          allTurns = [...allTurns, ...bufferTurns];
+          turnSource = `${transcriptResult.source}+buffer`;
+          logger.info("processor", "Appended buffer turns missing from transcript", {
+            session_id: sessionId,
+            transcriptTurns: transcriptResult.turns.length,
+            bufferTurns: bufferTurns.length
+          });
+        }
+      }
+    }
+    if (lastAssistantMessage && allTurns.length > 0) {
+      const lastTurn = allTurns[allTurns.length - 1];
+      if (!lastTurn.aiResponse) {
+        lastTurn.aiResponse = lastAssistantMessage;
+      }
+    }
+    const ended = (/* @__PURE__ */ new Date()).toISOString();
+    let started = allTurns.length > 0 && allTurns[0].timestamp ? allTurns[0].timestamp : ended;
+    const sessionsDir = path7.join(vaultDir, "sessions");
+    const sessionFileName = `${sessionNoteId(sessionId)}.md`;
+    let existingContent;
+    const duplicatePaths = [];
+    try {
+      for (const dateDir of fs5.readdirSync(sessionsDir)) {
+        const candidate = path7.join(sessionsDir, dateDir, sessionFileName);
+        try {
+          const content = fs5.readFileSync(candidate, "utf-8");
+          if (!existingContent || content.length > existingContent.length) {
+            existingContent = content;
+          }
+          duplicatePaths.push(candidate);
+        } catch {
+        }
+      }
+    } catch {
+    }
+    let existingTurnCount = 0;
+    if (existingContent) {
+      const startedMatch = existingContent.match(/^started:\s*"?(.+?)"?\s*$/m);
+      if (startedMatch) started = startedMatch[1];
+      const turnMatches = existingContent.match(/^### Turn \d+/gm);
+      existingTurnCount = turnMatches?.length ?? 0;
+    }
+    const writtenFiles = sessionFilePaths.get(sessionId) ?? /* @__PURE__ */ new Set();
+    const artifactCandidates = collectArtifactCandidates(
+      writtenFiles,
+      { artifact_extensions: config.capture.artifact_extensions },
+      process.cwd()
+    );
+    if (allTurns.length === 0 && existingTurnCount > 0) {
+      logger.warn("processor", "Transcript unreadable, skipping rewrite to preserve existing data", { session_id: sessionId, existingTurns: existingTurnCount });
+      return;
+    }
+    if (allTurns.length > 0 && allTurns.length === existingTurnCount && lastBatch.length === 0 && artifactCandidates.length === 0) {
+      logger.debug("processor", "No new turns, skipping session rewrite", { session_id: sessionId, turns: allTurns.length });
+      return;
+    }
+    const conversationText = allTurns.map((t, i) => {
+      const parts = [`### Turn ${i + 1}`];
+      if (t.prompt) parts.push(`Prompt: ${t.prompt}`);
+      if (t.toolCount > 0) parts.push(`Tools: ${t.toolCount} calls`);
+      if (t.aiResponse) parts.push(`Response: ${t.aiResponse}`);
+      return parts.join("\n");
+    }).join("\n\n");
+    const conversationSection = `## Conversation
+
+${conversationText}`;
+    const observationPromise = lastBatch.length > 0 ? processor.process(lastBatch, sessionId).catch((err) => {
+      logger.warn("processor", "Observation extraction failed", { session_id: sessionId, error: err.message });
+      return null;
+    }) : Promise.resolve(null);
+    const artifactPromise = artifactCandidates.length > 0 ? processor.classifyArtifacts(artifactCandidates, sessionId).then((classified) => captureArtifacts(artifactCandidates, classified, sessionId, { vault, ...indexDeps }, lineageGraph)).catch((err) => {
+      logger.warn("processor", "Artifact capture failed", { session_id: sessionId, error: err.message });
+    }) : Promise.resolve();
+    const summaryPromise = processor.summarizeSession(conversationSection, sessionId, user).catch((err) => {
+      logger.warn("processor", "Session summarization failed", { session_id: sessionId, error: err.message });
+      return null;
+    });
+    const [observationResult, , summaryResult] = await Promise.all([observationPromise, artifactPromise, summaryPromise]);
+    if (observationResult && !observationResult.degraded) {
+      writeObservations(observationResult.observations, sessionId, { vault, ...indexDeps });
+    }
+    const date = started.slice(0, 10);
+    const relativePath = sessionRelativePath(sessionId, date);
+    const targetFullPath = path7.join(vaultDir, relativePath);
+    for (const dup of duplicatePaths) {
+      if (dup !== targetFullPath) {
+        try {
+          fs5.unlinkSync(dup);
+          logger.debug("lifecycle", "Removed duplicate session file", { path: dup });
+        } catch {
+        }
+      }
+    }
+    const attachmentsDir = path7.join(vaultDir, "attachments");
+    const hasImages = allTurns.some((t) => t.images?.length);
+    if (hasImages) {
+      fs5.mkdirSync(attachmentsDir, { recursive: true });
+    }
+    const turnImageNames = /* @__PURE__ */ new Map();
+    for (let i = 0; i < allTurns.length; i++) {
+      const turn = allTurns[i];
+      if (!turn.images?.length) continue;
+      const names = [];
+      for (let j = 0; j < turn.images.length; j++) {
+        const img = turn.images[j];
+        const ext = extensionForMimeType(img.mediaType);
+        const filename = `${bareSessionId(sessionId)}-t${i + 1}-${j + 1}.${ext}`;
+        const filePath = path7.join(attachmentsDir, filename);
+        if (!fs5.existsSync(filePath)) {
+          fs5.writeFileSync(filePath, Buffer.from(img.data, "base64"));
+          logger.debug("processor", "Image saved", { filename, turn: i + 1 });
+        }
+        names.push(filename);
+      }
+      turnImageNames.set(i, names);
+    }
+    let title = `Session ${sessionId}`;
+    let narrative = "";
+    if (summaryResult) {
+      title = summaryResult.title;
+      narrative = summaryResult.summary;
+    }
+    const relatedMemories = index.query({ type: "memory", limit: RELATED_MEMORIES_LIMIT }).filter((n) => {
+      const fm = n.frontmatter;
+      return fm.session === sessionNoteId(sessionId) || fm.session === sessionId;
+    }).map((n) => ({ id: n.id, title: n.title }));
+    const summary = formatSessionBody({
+      title,
+      narrative,
+      sessionId,
+      user,
+      started,
+      ended,
+      branch: sessionMeta?.branch,
+      relatedMemories,
+      turns: allTurns.map((t, i) => ({
+        prompt: t.prompt,
+        toolCount: t.toolCount,
+        aiResponse: t.aiResponse,
+        images: turnImageNames.get(i)
+      }))
+    });
+    const parentId = lineageGraph.getParent(sessionId);
+    const parentLink = parentId ? lineageGraph.getLinks().find((l) => l.child === sessionId) : void 0;
+    vault.writeSession({
+      id: sessionId,
+      user,
+      started,
+      ended,
+      branch: sessionMeta?.branch,
+      parent: parentId ? sessionWikilink(parentId) : void 0,
+      parent_reason: parentLink?.signal,
+      tools_used: allTurns.reduce((sum, t) => sum + t.toolCount, 0),
+      summary
+    });
+    indexAndEmbed(
+      relativePath,
+      sessionNoteId(sessionId),
+      narrative,
+      { type: "session", session_id: sessionId },
+      indexDeps
+    );
+    logger.debug("processor", "Session turns", { source: turnSource, total: allTurns.length });
+    await artifactPromise;
+    if (!parentId && vectorIndex && narrative) {
+      generateEmbedding(embeddingProvider, narrative).then(async (emb) => {
+        const candidates = vectorIndex.search(emb.embedding, { limit: LINEAGE_SIMILARITY_CANDIDATES }).filter((r) => r.metadata.type === "session" && r.id !== sessionNoteId(sessionId));
+        if (candidates.length === 0) return;
+        const candidateNotes = index.queryByIds(candidates.map((c) => c.id));
+        const noteMap = new Map(candidateNotes.map((n) => [n.id, n]));
+        const scores = await Promise.all(candidates.map(async (candidate) => {
+          const note = noteMap.get(candidate.id);
+          if (!note) return { id: candidate.id, score: 0 };
+          try {
+            const prompt = buildSimilarityPrompt(narrative, note.content.slice(0, CANDIDATE_CONTENT_PREVIEW));
+            const response = await llmProvider.summarize(prompt, { maxTokens: LINEAGE_SIMILARITY_MAX_TOKENS });
+            const score = extractNumber(response.text);
+            return { id: candidate.id, score: isNaN(score) ? 0 : score };
+          } catch {
+            return { id: candidate.id, score: 0 };
+          }
+        }));
+        const best = scores.reduce((a, b) => b.score > a.score ? b : a);
+        if (best.score >= LINEAGE_SIMILARITY_THRESHOLD) {
+          const bestParentId = bareSessionId(best.id);
+          const confidence = best.score >= LINEAGE_SIMILARITY_HIGH_CONFIDENCE ? "high" : "medium";
+          lineageGraph.addLink({
+            parent: bestParentId,
+            child: sessionId,
+            signal: "semantic_similarity",
+            confidence
+          });
+          try {
+            vault.updateNoteFrontmatter(relativePath, {
+              parent: sessionWikilink(bestParentId),
+              parent_reason: "semantic_similarity"
+            });
+            indexNote(index, vaultDir, relativePath);
+          } catch {
+          }
+          logger.info("lineage", "LLM similarity parent detected", {
+            child: sessionId,
+            parent: bestParentId,
+            score: best.score
+          });
+        }
+      }).catch((err) => logger.debug("lineage", "Similarity detection failed", { error: err.message }));
+    }
+    logger.info("processor", "Session note written", { session_id: sessionId, path: relativePath });
+  }
+  server.registerRoute("POST", "/context", async (body) => {
+    const { session_id, branch } = ContextBody.parse(body);
+    logger.debug("hooks", "Session context query", { session_id });
+    try {
+      const parts = [];
+      const plans = index.query({ type: "plan" });
+      const activePlans = plans.filter((p) => {
+        const status = p.frontmatter.status;
+        return status === "active" || status === "in_progress";
+      });
+      if (activePlans.length > 0) {
+        const planLines = activePlans.slice(0, SESSION_CONTEXT_MAX_PLANS).map((p) => {
+          const status = p.frontmatter.status;
+          return `- **${p.title}** (${status}) \`[${p.id}]\``;
+        });
+        parts.push(`### Active Plans
+${planLines.join("\n")}`);
+      }
+      if (session_id) {
+        const parentId = lineageGraph.getParent(session_id);
+        if (parentId) {
+          const parentNotes = index.queryByIds([sessionNoteId(parentId)]);
+          if (parentNotes.length > 0) {
+            const parent = parentNotes[0];
+            parts.push(`### Previous Session
+- **${parent.title}**: ${parent.content.slice(0, CONTEXT_SESSION_PREVIEW_CHARS)} \`[${parent.id}]\``);
+          }
+        }
+      }
+      if (branch) {
+        parts.push(`Branch:: \`${branch}\``);
+      }
+      if (parts.length > 0) {
+        return { text: parts.join("\n\n") };
+      }
+      return { text: "" };
+    } catch (error) {
+      logger.error("daemon", "Session context failed", { error: error.message });
+      return { text: "" };
+    }
+  });
+  const PromptContextBody = external_exports.object({
+    prompt: external_exports.string(),
+    session_id: external_exports.string().optional()
+  });
+  server.registerRoute("POST", "/context/prompt", async (body) => {
+    const { prompt, session_id } = PromptContextBody.parse(body);
+    if (!prompt || prompt.length < PROMPT_CONTEXT_MIN_LENGTH || !vectorIndex) {
+      return { text: "" };
+    }
+    try {
+      const emb = await generateEmbedding(embeddingProvider, prompt.slice(0, EMBEDDING_INPUT_LIMIT));
+      const results = vectorIndex.search(emb.embedding, {
+        limit: PROMPT_CONTEXT_MAX_MEMORIES,
+        type: "memory",
+        relativeThreshold: PROMPT_CONTEXT_MIN_SIMILARITY
+      });
+      if (results.length === 0) return { text: "" };
+      const noteMap = new Map(
+        index.queryByIds(results.map((r) => r.id)).map((n) => [n.id, n])
+      );
+      const lines = [];
+      for (const r of results) {
+        const note = noteMap.get(r.id);
+        if (!note) continue;
+        const fm = note.frontmatter;
+        if (fm.status === "superseded" || fm.status === "archived") continue;
+        const obsType = fm.observation_type ?? "note";
+        lines.push(`- [${obsType}] ${note.title}: ${note.content.slice(0, CONTENT_SNIPPET_CHARS)} \`[${note.id}]\``);
+      }
+      if (lines.length === 0) return { text: "" };
+      const injected = `**Relevant memories for this task:**
+${lines.join("\n")}`;
+      logger.debug("context", "Prompt context injected", {
+        session_id,
+        memories: lines.length,
+        prompt_preview: prompt.slice(0, 50)
+      });
+      return { text: injected };
+    } catch (err) {
+      logger.debug("context", "Prompt context failed", { error: err.message });
+      return { text: "" };
+    }
+  });
+  await server.start();
+  logger.info("daemon", "Daemon ready", { vault: vaultDir, port: server.port });
+  const shutdown = async (signal) => {
+    logger.info("daemon", `${signal} received`);
+    if (activeStopProcessing) {
+      logger.info("daemon", "Waiting for active stop processing to complete...");
+      await activeStopProcessing;
+    }
+    planWatcher.stopFileWatcher();
+    registry.destroy();
+    await server.stop();
+    vectorIndex?.close();
+    index.close();
+    logger.close();
+    process.exit(0);
+  };
+  process.on("SIGTERM", () => shutdown("SIGTERM"));
+  process.on("SIGINT", () => shutdown("SIGINT"));
+}
+var __filename = fileURLToPath2(import.meta.url);
+if (process.argv[1] === __filename) {
+  main().catch((err) => {
+    process.stderr.write(`[mycod] Fatal: ${err.message}
+`);
+    process.exit(1);
+  });
+}
+export {
+  migrateMemoryFiles
+};
+/*! Bundled license information:
+
+chokidar/index.js:
+  (*! chokidar - MIT License (c) 2012 Paul Miller (paulmillr.com) *)
+*/
+//# sourceMappingURL=main-5W4ADOBG.js.map