@swestash/agent-lens 0.1.0

package/dist/agent-lens.js

@@ -0,0 +1,3572 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { readFileSync as readFileSync5 } from "fs";
+import { dirname as dirname6, join as join9 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+
+// ../../node_modules/.pnpm/cac@6.7.14/node_modules/cac/dist/index.mjs
+import { EventEmitter } from "events";
+function toArr(any) {
+  return any == null ? [] : Array.isArray(any) ? any : [any];
+}
+function toVal(out, key, val, opts) {
+  var x, old = out[key], nxt = !!~opts.string.indexOf(key) ? val == null || val === true ? "" : String(val) : typeof val === "boolean" ? val : !!~opts.boolean.indexOf(key) ? val === "false" ? false : val === "true" || (out._.push((x = +val, x * 0 === 0) ? x : val), !!val) : (x = +val, x * 0 === 0) ? x : val;
+  out[key] = old == null ? nxt : Array.isArray(old) ? old.concat(nxt) : [old, nxt];
+}
+function mri2(args, opts) {
+  args = args || [];
+  opts = opts || {};
+  var k, arr, arg, name, val, out = { _: [] };
+  var i = 0, j = 0, idx = 0, len = args.length;
+  const alibi = opts.alias !== void 0;
+  const strict = opts.unknown !== void 0;
+  const defaults = opts.default !== void 0;
+  opts.alias = opts.alias || {};
+  opts.string = toArr(opts.string);
+  opts.boolean = toArr(opts.boolean);
+  if (alibi) {
+    for (k in opts.alias) {
+      arr = opts.alias[k] = toArr(opts.alias[k]);
+      for (i = 0; i < arr.length; i++) {
+        (opts.alias[arr[i]] = arr.concat(k)).splice(i, 1);
+      }
+    }
+  }
+  for (i = opts.boolean.length; i-- > 0; ) {
+    arr = opts.alias[opts.boolean[i]] || [];
+    for (j = arr.length; j-- > 0; ) opts.boolean.push(arr[j]);
+  }
+  for (i = opts.string.length; i-- > 0; ) {
+    arr = opts.alias[opts.string[i]] || [];
+    for (j = arr.length; j-- > 0; ) opts.string.push(arr[j]);
+  }
+  if (defaults) {
+    for (k in opts.default) {
+      name = typeof opts.default[k];
+      arr = opts.alias[k] = opts.alias[k] || [];
+      if (opts[name] !== void 0) {
+        opts[name].push(k);
+        for (i = 0; i < arr.length; i++) {
+          opts[name].push(arr[i]);
+        }
+      }
+    }
+  }
+  const keys = strict ? Object.keys(opts.alias) : [];
+  for (i = 0; i < len; i++) {
+    arg = args[i];
+    if (arg === "--") {
+      out._ = out._.concat(args.slice(++i));
+      break;
+    }
+    for (j = 0; j < arg.length; j++) {
+      if (arg.charCodeAt(j) !== 45) break;
+    }
+    if (j === 0) {
+      out._.push(arg);
+    } else if (arg.substring(j, j + 3) === "no-") {
+      name = arg.substring(j + 3);
+      if (strict && !~keys.indexOf(name)) {
+        return opts.unknown(arg);
+      }
+      out[name] = false;
+    } else {
+      for (idx = j + 1; idx < arg.length; idx++) {
+        if (arg.charCodeAt(idx) === 61) break;
+      }
+      name = arg.substring(j, idx);
+      val = arg.substring(++idx) || (i + 1 === len || ("" + args[i + 1]).charCodeAt(0) === 45 || args[++i]);
+      arr = j === 2 ? [name] : name;
+      for (idx = 0; idx < arr.length; idx++) {
+        name = arr[idx];
+        if (strict && !~keys.indexOf(name)) return opts.unknown("-".repeat(j) + name);
+        toVal(out, name, idx + 1 < arr.length || val, opts);
+      }
+    }
+  }
+  if (defaults) {
+    for (k in opts.default) {
+      if (out[k] === void 0) {
+        out[k] = opts.default[k];
+      }
+    }
+  }
+  if (alibi) {
+    for (k in out) {
+      arr = opts.alias[k] || [];
+      while (arr.length > 0) {
+        out[arr.shift()] = out[k];
+      }
+    }
+  }
+  return out;
+}
+var removeBrackets = (v) => v.replace(/[<[].+/, "").trim();
+var findAllBrackets = (v) => {
+  const ANGLED_BRACKET_RE_GLOBAL = /<([^>]+)>/g;
+  const SQUARE_BRACKET_RE_GLOBAL = /\[([^\]]+)\]/g;
+  const res = [];
+  const parse = (match) => {
+    let variadic = false;
+    let value = match[1];
+    if (value.startsWith("...")) {
+      value = value.slice(3);
+      variadic = true;
+    }
+    return {
+      required: match[0].startsWith("<"),
+      value,
+      variadic
+    };
+  };
+  let angledMatch;
+  while (angledMatch = ANGLED_BRACKET_RE_GLOBAL.exec(v)) {
+    res.push(parse(angledMatch));
+  }
+  let squareMatch;
+  while (squareMatch = SQUARE_BRACKET_RE_GLOBAL.exec(v)) {
+    res.push(parse(squareMatch));
+  }
+  return res;
+};
+var getMriOptions = (options) => {
+  const result = { alias: {}, boolean: [] };
+  for (const [index, option] of options.entries()) {
+    if (option.names.length > 1) {
+      result.alias[option.names[0]] = option.names.slice(1);
+    }
+    if (option.isBoolean) {
+      if (option.negated) {
+        const hasStringTypeOption = options.some((o, i) => {
+          return i !== index && o.names.some((name) => option.names.includes(name)) && typeof o.required === "boolean";
+        });
+        if (!hasStringTypeOption) {
+          result.boolean.push(option.names[0]);
+        }
+      } else {
+        result.boolean.push(option.names[0]);
+      }
+    }
+  }
+  return result;
+};
+var findLongest = (arr) => {
+  return arr.sort((a, b) => {
+    return a.length > b.length ? -1 : 1;
+  })[0];
+};
+var padRight = (str, length) => {
+  return str.length >= length ? str : `${str}${" ".repeat(length - str.length)}`;
+};
+var camelcase = (input) => {
+  return input.replace(/([a-z])-([a-z])/g, (_, p1, p2) => {
+    return p1 + p2.toUpperCase();
+  });
+};
+var setDotProp = (obj, keys, val) => {
+  let i = 0;
+  let length = keys.length;
+  let t = obj;
+  let x;
+  for (; i < length; ++i) {
+    x = t[keys[i]];
+    t = t[keys[i]] = i === length - 1 ? val : x != null ? x : !!~keys[i + 1].indexOf(".") || !(+keys[i + 1] > -1) ? {} : [];
+  }
+};
+var setByType = (obj, transforms) => {
+  for (const key of Object.keys(transforms)) {
+    const transform = transforms[key];
+    if (transform.shouldTransform) {
+      obj[key] = Array.prototype.concat.call([], obj[key]);
+      if (typeof transform.transformFunction === "function") {
+        obj[key] = obj[key].map(transform.transformFunction);
+      }
+    }
+  }
+};
+var getFileName = (input) => {
+  const m = /([^\\\/]+)$/.exec(input);
+  return m ? m[1] : "";
+};
+var camelcaseOptionName = (name) => {
+  return name.split(".").map((v, i) => {
+    return i === 0 ? camelcase(v) : v;
+  }).join(".");
+};
+var CACError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = this.constructor.name;
+    if (typeof Error.captureStackTrace === "function") {
+      Error.captureStackTrace(this, this.constructor);
+    } else {
+      this.stack = new Error(message).stack;
+    }
+  }
+};
+var Option = class {
+  constructor(rawName, description, config) {
+    this.rawName = rawName;
+    this.description = description;
+    this.config = Object.assign({}, config);
+    rawName = rawName.replace(/\.\*/g, "");
+    this.negated = false;
+    this.names = removeBrackets(rawName).split(",").map((v) => {
+      let name = v.trim().replace(/^-{1,2}/, "");
+      if (name.startsWith("no-")) {
+        this.negated = true;
+        name = name.replace(/^no-/, "");
+      }
+      return camelcaseOptionName(name);
+    }).sort((a, b) => a.length > b.length ? 1 : -1);
+    this.name = this.names[this.names.length - 1];
+    if (this.negated && this.config.default == null) {
+      this.config.default = true;
+    }
+    if (rawName.includes("<")) {
+      this.required = true;
+    } else if (rawName.includes("[")) {
+      this.required = false;
+    } else {
+      this.isBoolean = true;
+    }
+  }
+};
+var processArgs = process.argv;
+var platformInfo = `${process.platform}-${process.arch} node-${process.version}`;
+var Command = class {
+  constructor(rawName, description, config = {}, cli2) {
+    this.rawName = rawName;
+    this.description = description;
+    this.config = config;
+    this.cli = cli2;
+    this.options = [];
+    this.aliasNames = [];
+    this.name = removeBrackets(rawName);
+    this.args = findAllBrackets(rawName);
+    this.examples = [];
+  }
+  usage(text) {
+    this.usageText = text;
+    return this;
+  }
+  allowUnknownOptions() {
+    this.config.allowUnknownOptions = true;
+    return this;
+  }
+  ignoreOptionDefaultValue() {
+    this.config.ignoreOptionDefaultValue = true;
+    return this;
+  }
+  version(version2, customFlags = "-v, --version") {
+    this.versionNumber = version2;
+    this.option(customFlags, "Display version number");
+    return this;
+  }
+  example(example) {
+    this.examples.push(example);
+    return this;
+  }
+  option(rawName, description, config) {
+    const option = new Option(rawName, description, config);
+    this.options.push(option);
+    return this;
+  }
+  alias(name) {
+    this.aliasNames.push(name);
+    return this;
+  }
+  action(callback) {
+    this.commandAction = callback;
+    return this;
+  }
+  isMatched(name) {
+    return this.name === name || this.aliasNames.includes(name);
+  }
+  get isDefaultCommand() {
+    return this.name === "" || this.aliasNames.includes("!");
+  }
+  get isGlobalCommand() {
+    return this instanceof GlobalCommand;
+  }
+  hasOption(name) {
+    name = name.split(".")[0];
+    return this.options.find((option) => {
+      return option.names.includes(name);
+    });
+  }
+  outputHelp() {
+    const { name, commands } = this.cli;
+    const {
+      versionNumber,
+      options: globalOptions,
+      helpCallback
+    } = this.cli.globalCommand;
+    let sections = [
+      {
+        body: `${name}${versionNumber ? `/${versionNumber}` : ""}`
+      }
+    ];
+    sections.push({
+      title: "Usage",
+      body: `  $ ${name} ${this.usageText || this.rawName}`
+    });
+    const showCommands = (this.isGlobalCommand || this.isDefaultCommand) && commands.length > 0;
+    if (showCommands) {
+      const longestCommandName = findLongest(commands.map((command) => command.rawName));
+      sections.push({
+        title: "Commands",
+        body: commands.map((command) => {
+          return `  ${padRight(command.rawName, longestCommandName.length)}  ${command.description}`;
+        }).join("\n")
+      });
+      sections.push({
+        title: `For more info, run any command with the \`--help\` flag`,
+        body: commands.map((command) => `  $ ${name}${command.name === "" ? "" : ` ${command.name}`} --help`).join("\n")
+      });
+    }
+    let options = this.isGlobalCommand ? globalOptions : [...this.options, ...globalOptions || []];
+    if (!this.isGlobalCommand && !this.isDefaultCommand) {
+      options = options.filter((option) => option.name !== "version");
+    }
+    if (options.length > 0) {
+      const longestOptionName = findLongest(options.map((option) => option.rawName));
+      sections.push({
+        title: "Options",
+        body: options.map((option) => {
+          return `  ${padRight(option.rawName, longestOptionName.length)}  ${option.description} ${option.config.default === void 0 ? "" : `(default: ${option.config.default})`}`;
+        }).join("\n")
+      });
+    }
+    if (this.examples.length > 0) {
+      sections.push({
+        title: "Examples",
+        body: this.examples.map((example) => {
+          if (typeof example === "function") {
+            return example(name);
+          }
+          return example;
+        }).join("\n")
+      });
+    }
+    if (helpCallback) {
+      sections = helpCallback(sections) || sections;
+    }
+    console.log(sections.map((section) => {
+      return section.title ? `${section.title}:
+${section.body}` : section.body;
+    }).join("\n\n"));
+  }
+  outputVersion() {
+    const { name } = this.cli;
+    const { versionNumber } = this.cli.globalCommand;
+    if (versionNumber) {
+      console.log(`${name}/${versionNumber} ${platformInfo}`);
+    }
+  }
+  checkRequiredArgs() {
+    const minimalArgsCount = this.args.filter((arg) => arg.required).length;
+    if (this.cli.args.length < minimalArgsCount) {
+      throw new CACError(`missing required args for command \`${this.rawName}\``);
+    }
+  }
+  checkUnknownOptions() {
+    const { options, globalCommand } = this.cli;
+    if (!this.config.allowUnknownOptions) {
+      for (const name of Object.keys(options)) {
+        if (name !== "--" && !this.hasOption(name) && !globalCommand.hasOption(name)) {
+          throw new CACError(`Unknown option \`${name.length > 1 ? `--${name}` : `-${name}`}\``);
+        }
+      }
+    }
+  }
+  checkOptionValue() {
+    const { options: parsedOptions, globalCommand } = this.cli;
+    const options = [...globalCommand.options, ...this.options];
+    for (const option of options) {
+      const value = parsedOptions[option.name.split(".")[0]];
+      if (option.required) {
+        const hasNegated = options.some((o) => o.negated && o.names.includes(option.name));
+        if (value === true || value === false && !hasNegated) {
+          throw new CACError(`option \`${option.rawName}\` value is missing`);
+        }
+      }
+    }
+  }
+};
+var GlobalCommand = class extends Command {
+  constructor(cli2) {
+    super("@@global@@", "", {}, cli2);
+  }
+};
+var __assign = Object.assign;
+var CAC = class extends EventEmitter {
+  constructor(name = "") {
+    super();
+    this.name = name;
+    this.commands = [];
+    this.rawArgs = [];
+    this.args = [];
+    this.options = {};
+    this.globalCommand = new GlobalCommand(this);
+    this.globalCommand.usage("<command> [options]");
+  }
+  usage(text) {
+    this.globalCommand.usage(text);
+    return this;
+  }
+  command(rawName, description, config) {
+    const command = new Command(rawName, description || "", config, this);
+    command.globalCommand = this.globalCommand;
+    this.commands.push(command);
+    return command;
+  }
+  option(rawName, description, config) {
+    this.globalCommand.option(rawName, description, config);
+    return this;
+  }
+  help(callback) {
+    this.globalCommand.option("-h, --help", "Display this message");
+    this.globalCommand.helpCallback = callback;
+    this.showHelpOnExit = true;
+    return this;
+  }
+  version(version2, customFlags = "-v, --version") {
+    this.globalCommand.version(version2, customFlags);
+    this.showVersionOnExit = true;
+    return this;
+  }
+  example(example) {
+    this.globalCommand.example(example);
+    return this;
+  }
+  outputHelp() {
+    if (this.matchedCommand) {
+      this.matchedCommand.outputHelp();
+    } else {
+      this.globalCommand.outputHelp();
+    }
+  }
+  outputVersion() {
+    this.globalCommand.outputVersion();
+  }
+  setParsedInfo({ args, options }, matchedCommand, matchedCommandName) {
+    this.args = args;
+    this.options = options;
+    if (matchedCommand) {
+      this.matchedCommand = matchedCommand;
+    }
+    if (matchedCommandName) {
+      this.matchedCommandName = matchedCommandName;
+    }
+    return this;
+  }
+  unsetMatchedCommand() {
+    this.matchedCommand = void 0;
+    this.matchedCommandName = void 0;
+  }
+  parse(argv = processArgs, {
+    run = true
+  } = {}) {
+    this.rawArgs = argv;
+    if (!this.name) {
+      this.name = argv[1] ? getFileName(argv[1]) : "cli";
+    }
+    let shouldParse = true;
+    for (const command of this.commands) {
+      const parsed = this.mri(argv.slice(2), command);
+      const commandName = parsed.args[0];
+      if (command.isMatched(commandName)) {
+        shouldParse = false;
+        const parsedInfo = __assign(__assign({}, parsed), {
+          args: parsed.args.slice(1)
+        });
+        this.setParsedInfo(parsedInfo, command, commandName);
+        this.emit(`command:${commandName}`, command);
+      }
+    }
+    if (shouldParse) {
+      for (const command of this.commands) {
+        if (command.name === "") {
+          shouldParse = false;
+          const parsed = this.mri(argv.slice(2), command);
+          this.setParsedInfo(parsed, command);
+          this.emit(`command:!`, command);
+        }
+      }
+    }
+    if (shouldParse) {
+      const parsed = this.mri(argv.slice(2));
+      this.setParsedInfo(parsed);
+    }
+    if (this.options.help && this.showHelpOnExit) {
+      this.outputHelp();
+      run = false;
+      this.unsetMatchedCommand();
+    }
+    if (this.options.version && this.showVersionOnExit && this.matchedCommandName == null) {
+      this.outputVersion();
+      run = false;
+      this.unsetMatchedCommand();
+    }
+    const parsedArgv = { args: this.args, options: this.options };
+    if (run) {
+      this.runMatchedCommand();
+    }
+    if (!this.matchedCommand && this.args[0]) {
+      this.emit("command:*");
+    }
+    return parsedArgv;
+  }
+  mri(argv, command) {
+    const cliOptions = [
+      ...this.globalCommand.options,
+      ...command ? command.options : []
+    ];
+    const mriOptions = getMriOptions(cliOptions);
+    let argsAfterDoubleDashes = [];
+    const doubleDashesIndex = argv.indexOf("--");
+    if (doubleDashesIndex > -1) {
+      argsAfterDoubleDashes = argv.slice(doubleDashesIndex + 1);
+      argv = argv.slice(0, doubleDashesIndex);
+    }
+    let parsed = mri2(argv, mriOptions);
+    parsed = Object.keys(parsed).reduce((res, name) => {
+      return __assign(__assign({}, res), {
+        [camelcaseOptionName(name)]: parsed[name]
+      });
+    }, { _: [] });
+    const args = parsed._;
+    const options = {
+      "--": argsAfterDoubleDashes
+    };
+    const ignoreDefault = command && command.config.ignoreOptionDefaultValue ? command.config.ignoreOptionDefaultValue : this.globalCommand.config.ignoreOptionDefaultValue;
+    let transforms = /* @__PURE__ */ Object.create(null);
+    for (const cliOption of cliOptions) {
+      if (!ignoreDefault && cliOption.config.default !== void 0) {
+        for (const name of cliOption.names) {
+          options[name] = cliOption.config.default;
+        }
+      }
+      if (Array.isArray(cliOption.config.type)) {
+        if (transforms[cliOption.name] === void 0) {
+          transforms[cliOption.name] = /* @__PURE__ */ Object.create(null);
+          transforms[cliOption.name]["shouldTransform"] = true;
+          transforms[cliOption.name]["transformFunction"] = cliOption.config.type[0];
+        }
+      }
+    }
+    for (const key of Object.keys(parsed)) {
+      if (key !== "_") {
+        const keys = key.split(".");
+        setDotProp(options, keys, parsed[key]);
+        setByType(options, transforms);
+      }
+    }
+    return {
+      args,
+      options
+    };
+  }
+  runMatchedCommand() {
+    const { args, options, matchedCommand: command } = this;
+    if (!command || !command.commandAction)
+      return;
+    command.checkUnknownOptions();
+    command.checkOptionValue();
+    command.checkRequiredArgs();
+    const actionArgs = [];
+    command.args.forEach((arg, index) => {
+      if (arg.variadic) {
+        actionArgs.push(args.slice(index));
+      } else {
+        actionArgs.push(args[index]);
+      }
+    });
+    actionArgs.push(options);
+    return command.commandAction.apply(this, actionArgs);
+  }
+};
+var cac = (name = "") => new CAC(name);
+
+// ../core/dist/schema.js
+var SCHEMA_VERSION = 8;
+var SCHEMA_SQL = (
+  /* sql */
+  `
+PRAGMA journal_mode = WAL;
+PRAGMA foreign_keys = ON;
+
+-- Schema/version bookkeeping ------------------------------------------------
+CREATE TABLE IF NOT EXISTS meta (
+  key   TEXT PRIMARY KEY,
+  value TEXT NOT NULL
+);
+
+-- An agent *type* (e.g. 'claude-code'). Extensible to other agents. ---------
+CREATE TABLE IF NOT EXISTS agents (
+  id   TEXT PRIMARY KEY,           -- 'claude-code'
+  name TEXT NOT NULL,              -- 'Claude Code CLI'
+  kind TEXT NOT NULL DEFAULT 'cli'
+);
+
+-- A configured source = a labeled agent *instance* (e.g. account 'personal' --
+-- of agent 'claude-code' rooted at ~/.claude). Sessions belong to a source. --
+CREATE TABLE IF NOT EXISTS sources (
+  id         TEXT PRIMARY KEY,     -- the (unique) label, e.g. 'personal'
+  label      TEXT NOT NULL,
+  agent_id   TEXT NOT NULL REFERENCES agents(id),
+  config_dir TEXT
+);
+
+-- A project = a working directory a session ran in. ------------------------
+CREATE TABLE IF NOT EXISTS projects (
+  id          TEXT PRIMARY KEY,    -- stable hash of (agent_id, path)
+  agent_id    TEXT NOT NULL REFERENCES agents(id),
+  path        TEXT NOT NULL,       -- decoded absolute cwd
+  encoded_dir TEXT,                -- original '-home-...' archive dir name
+  first_seen  TEXT,                -- ISO8601
+  last_seen   TEXT,
+  UNIQUE (agent_id, path)
+);
+
+-- A session = one transcript file (sessionId). -----------------------------
+CREATE TABLE IF NOT EXISTS sessions (
+  id                TEXT PRIMARY KEY,   -- sessionId (UUID)
+  agent_id          TEXT NOT NULL REFERENCES agents(id),
+  source_id         TEXT REFERENCES sources(id),
+  project_id        TEXT REFERENCES projects(id),
+  slug              TEXT,
+  ai_title          TEXT,
+  cli_version       TEXT,
+  entrypoint        TEXT,
+  git_branch        TEXT,
+  is_sidechain      INTEGER NOT NULL DEFAULT 0,  -- 1 = subagent thread
+  spawn_parent_id   TEXT,                          -- structural parent from path (<parent>/subagents/\u2026); raw link hint, set at ingest
+  workflow_run_id   TEXT,                           -- for a Workflow-tool subagent: its run id (wf_<id>) from the path; groups fan-out by run
+  parent_session_id TEXT REFERENCES sessions(id), -- spawning session (subagents only); derived in rebuildDerived
+  parent_turn_id    TEXT REFERENCES turns(id),     -- the turn that spawned this subagent
+  started_at        TEXT,               -- ISO8601 of first event
+  ended_at          TEXT,               -- ISO8601 of last event
+  duration_ms       INTEGER,
+  event_count       INTEGER NOT NULL DEFAULT 0,
+  turn_count        INTEGER NOT NULL DEFAULT 0
+);
+CREATE INDEX IF NOT EXISTS idx_sessions_project ON sessions(project_id);
+CREATE INDEX IF NOT EXISTS idx_sessions_source ON sessions(source_id);
+CREATE INDEX IF NOT EXISTS idx_sessions_started ON sessions(started_at);
+CREATE INDEX IF NOT EXISTS idx_sessions_parent_session ON sessions(parent_session_id);
+CREATE INDEX IF NOT EXISTS idx_sessions_workflow_run ON sessions(workflow_run_id);
+CREATE INDEX IF NOT EXISTS idx_sessions_parent_turn ON sessions(parent_turn_id);
+
+-- A turn = user prompt -> assistant completion within a session. ------------
+CREATE TABLE IF NOT EXISTS turns (
+  id              TEXT PRIMARY KEY,      -- hash(session_id, seq)
+  session_id      TEXT NOT NULL REFERENCES sessions(id),
+  seq             INTEGER NOT NULL,      -- 0-based order within session
+  user_event_uuid TEXT,                  -- the originating user event
+  prompt_preview  TEXT,                  -- short, for lists (full text in events)
+  model           TEXT,                  -- model that answered this turn
+  started_at      TEXT,
+  ended_at        TEXT,
+  duration_ms     INTEGER,
+  UNIQUE (session_id, seq)
+);
+CREATE INDEX IF NOT EXISTS idx_turns_session ON turns(session_id);
+
+-- Every transcript line. uuid is the dedup key across archive versions. -----
+CREATE TABLE IF NOT EXISTS events (
+  uuid         TEXT PRIMARY KEY,
+  session_id   TEXT NOT NULL REFERENCES sessions(id),
+  turn_id      TEXT REFERENCES turns(id),
+  parent_uuid  TEXT,
+  seq          INTEGER,                  -- line order as first observed
+  type         TEXT NOT NULL,            -- user | assistant | system | attachment | ...
+  role         TEXT,                     -- user | assistant (message.role)
+  timestamp    TEXT,                     -- ISO8601
+  model        TEXT,
+  is_sidechain INTEGER NOT NULL DEFAULT 0,
+  is_meta      INTEGER NOT NULL DEFAULT 0,
+  text         TEXT,                     -- flattened text/thinking for search + preview
+  raw_json     BLOB NOT NULL,            -- original line, verbatim, gzip-compressed (ADR-011); read via unpackRaw()
+  source_file  TEXT                      -- archive path the canonical copy came from
+);
+CREATE INDEX IF NOT EXISTS idx_events_session ON events(session_id);
+CREATE INDEX IF NOT EXISTS idx_events_turn ON events(turn_id);
+CREATE INDEX IF NOT EXISTS idx_events_type ON events(type);
+CREATE INDEX IF NOT EXISTS idx_events_ts ON events(timestamp);
+
+-- Tool invocations (incl. subagents / Task calls). -------------------------
+CREATE TABLE IF NOT EXISTS tool_calls (
+  id                  TEXT PRIMARY KEY,  -- tool_use id, or hash
+  event_uuid          TEXT REFERENCES events(uuid),
+  session_id          TEXT NOT NULL REFERENCES sessions(id),
+  turn_id             TEXT REFERENCES turns(id),
+  tool_name           TEXT NOT NULL,     -- Edit, Write, Bash, Skill, Task, ...
+  caller              TEXT,
+  skill_name          TEXT,              -- when tool_name = Skill
+  skill_id            TEXT REFERENCES skills(id), -- the specific skill *version* this call fired (content hash); set in rebuildDerived
+  agent_type          TEXT,              -- subagent type (toolUseResult.agentType)
+  spawned_session_id  TEXT,              -- for Task/Agent: the subagent session id ('agent-'||agentId)
+  workflow_run_id     TEXT,              -- for Workflow: the run id (toolUseResult.runId, e.g. wf_<id>) \u2014 ties the run to its subagents
+  workflow_name       TEXT,              -- for Workflow: the workflow name (toolUseResult.workflowName)
+  resolved_model      TEXT,
+  status              TEXT,              -- success | error | ...
+  total_duration_ms   INTEGER,
+  total_tokens        INTEGER,
+  total_tool_use_count INTEGER,
+  input_json          TEXT,              -- tool input, verbatim
+  result_summary      TEXT               -- short result projection (no secrets dumped wholesale)
+);
+CREATE INDEX IF NOT EXISTS idx_tool_calls_session ON tool_calls(session_id);
+CREATE INDEX IF NOT EXISTS idx_tool_calls_tool ON tool_calls(tool_name);
+CREATE INDEX IF NOT EXISTS idx_tool_calls_skill ON tool_calls(skill_name);
+CREATE INDEX IF NOT EXISTS idx_tool_calls_skill_id ON tool_calls(skill_id);
+CREATE INDEX IF NOT EXISTS idx_tool_calls_spawned ON tool_calls(spawned_session_id);
+CREATE INDEX IF NOT EXISTS idx_tool_calls_workflow_run ON tool_calls(workflow_run_id);
+
+-- Skill *versions* (content-addressed). A skill firing injects the full SKILL.md body into the
+-- transcript as an isMeta user event (begins "Base directory for this skill: \u2026", then the body,
+-- then a trailing "ARGUMENTS: \u2026" block). That body is the only real skill content available (the
+-- trace carries no description/created_at). We identify a version by hashing the *normalized* body
+-- (Base-directory line + per-call ARGUMENTS block stripped, trailing whitespace trimmed) so the same
+-- content from either install / any args is one version, and a content change shows as a new row.
+-- Linked from tool_calls.skill_id in rebuildDerived. See plan: content-addressed skill versioning.
+CREATE TABLE IF NOT EXISTS skills (
+  id          TEXT PRIMARY KEY,   -- sha1 of name + NUL + normalized_body
+  name        TEXT NOT NULL,
+  base_dir    TEXT,               -- last-seen base directory (informational; NOT part of the hash)
+  body        TEXT NOT NULL,      -- normalized SKILL.md body (Base-dir line + ARGUMENTS block stripped)
+  summary     TEXT,               -- first heading/intro line, for list + detail display
+  body_bytes  INTEGER,
+  first_seen  TEXT,               -- earliest firing timestamp (MIN across firings)
+  last_seen   TEXT                -- latest firing timestamp (MAX across firings)
+);
+CREATE INDEX IF NOT EXISTS idx_skills_name ON skills(name);
+
+-- Token usage at the assistant-response grain. Cost derived later from model. --
+-- One API response is logged across multiple JSONL lines (one per content block: text + each
+-- tool_use), and Claude Code stamps the SAME usage object on every line. We dedup at the response
+-- grain via the unique (session_id, message_id) index so a response's tokens are counted ONCE, not
+-- once per content block (which over-counted tokens ~2.3x and cost ~3x). event_uuid stays the PK
+-- (the row is attached to whichever content-block event won the insert). --
+CREATE TABLE IF NOT EXISTS token_usage (
+  event_uuid                  TEXT PRIMARY KEY REFERENCES events(uuid),
+  session_id                  TEXT NOT NULL REFERENCES sessions(id),
+  turn_id                     TEXT REFERENCES turns(id),
+  message_id                  TEXT,              -- Anthropic response id (msg_\u2026); dedup key
+  model                       TEXT,
+  input_tokens                INTEGER NOT NULL DEFAULT 0,
+  output_tokens               INTEGER NOT NULL DEFAULT 0,
+  cache_creation_input_tokens INTEGER NOT NULL DEFAULT 0,
+  cache_read_input_tokens     INTEGER NOT NULL DEFAULT 0,
+  service_tier                TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_token_usage_session ON token_usage(session_id);
+-- Partial so rare usage rows lacking a message_id (e.g. <synthetic>) don't collide on NULL. --
+CREATE UNIQUE INDEX IF NOT EXISTS idx_token_usage_msg
+  ON token_usage(session_id, message_id) WHERE message_id IS NOT NULL;
+
+-- Heuristic classification (category + complexity), re-runnable. -----------
+-- scope: 'session' | 'turn'; target_id references that entity. -------------
+CREATE TABLE IF NOT EXISTS classifications (
+  scope             TEXT NOT NULL,       -- 'session' | 'turn'
+  target_id         TEXT NOT NULL,
+  category          TEXT,                -- feature | bugfix | refactor | docs | ops | review | ...
+  complexity_score  REAL,
+  complexity_band   TEXT,                -- trivial | small | medium | large | xl
+  signals_json      TEXT,               -- inputs used, for transparency/repro
+  classifier_version INTEGER NOT NULL DEFAULT 1,
+  PRIMARY KEY (scope, target_id)
+);
+
+-- Idempotent ingest bookkeeping per archive file. --------------------------
+CREATE TABLE IF NOT EXISTS ingest_state (
+  file_path       TEXT PRIMARY KEY,
+  size            INTEGER,
+  mtime_ms        INTEGER,
+  sha256          TEXT,
+  events_ingested INTEGER NOT NULL DEFAULT 0,
+  ingested_at     TEXT
+);
+
+-- Full-text search over event text (contentless external-content FTS). ------
+CREATE VIRTUAL TABLE IF NOT EXISTS events_fts USING fts5(
+  text,
+  content='events',
+  content_rowid='rowid'
+);
+
+-- Keep FTS in sync with events. --------------------------------------------
+CREATE TRIGGER IF NOT EXISTS events_ai AFTER INSERT ON events BEGIN
+  INSERT INTO events_fts(rowid, text) VALUES (new.rowid, new.text);
+END;
+CREATE TRIGGER IF NOT EXISTS events_ad AFTER DELETE ON events BEGIN
+  INSERT INTO events_fts(events_fts, rowid, text) VALUES ('delete', old.rowid, old.text);
+END;
+CREATE TRIGGER IF NOT EXISTS events_au AFTER UPDATE ON events
+WHEN old.text IS NOT new.text BEGIN
+  INSERT INTO events_fts(events_fts, rowid, text) VALUES ('delete', old.rowid, old.text);
+  INSERT INTO events_fts(rowid, text) VALUES (new.rowid, new.text);
+END;
+`
+);
+
+// ../core/dist/pricing.js
+var PRICE_TABLE = {
+  // Opus 4.0 / 4.1 launched at $15/$75; Opus 4.5 cut the Opus tier to $5/$25 and 4.6/4.7/4.8 kept it.
+  // The bare 'claude-opus-4' fallback stays at the legacy rate for 4.0/4.1; 4.5+ override below.
+  "claude-opus-4": { input: 15, output: 75, cacheWrite: 18.75, cacheRead: 1.5 },
+  "claude-opus-4-5": { input: 5, output: 25, cacheWrite: 6.25, cacheRead: 0.5 },
+  "claude-opus-4-6": { input: 5, output: 25, cacheWrite: 6.25, cacheRead: 0.5 },
+  "claude-opus-4-7": { input: 5, output: 25, cacheWrite: 6.25, cacheRead: 0.5 },
+  "claude-opus-4-8": { input: 5, output: 25, cacheWrite: 6.25, cacheRead: 0.5 },
+  "claude-fable-5": { input: 10, output: 50, cacheWrite: 12.5, cacheRead: 1 },
+  "claude-sonnet-4": { input: 3, output: 15, cacheWrite: 3.75, cacheRead: 0.3 },
+  "claude-haiku-4": { input: 1, output: 5, cacheWrite: 1.25, cacheRead: 0.1 },
+  "claude-3-5-haiku": { input: 0.8, output: 4, cacheWrite: 1, cacheRead: 0.08 },
+  "claude-3-5-sonnet": { input: 3, output: 15, cacheWrite: 3.75, cacheRead: 0.3 }
+};
+function rateForModel(model) {
+  if (!model)
+    return null;
+  let best = null;
+  for (const [prefix, rate] of Object.entries(PRICE_TABLE)) {
+    if (model.startsWith(prefix) && (!best || prefix.length > best.len)) {
+      best = { len: prefix.length, rate };
+    }
+  }
+  return best?.rate ?? null;
+}
+function costForUsage(model, u) {
+  const r = rateForModel(model);
+  if (!r)
+    return 0;
+  const M = 1e6;
+  return (u.input_tokens * r.input + u.output_tokens * r.output + u.cache_creation_input_tokens * r.cacheWrite + u.cache_read_input_tokens * r.cacheRead) / M;
+}
+
+// ../core/dist/markdown.js
+function fence(s) {
+  return s.length > 2e3 ? s.slice(0, 2e3) + "\n\u2026 (truncated)" : s;
+}
+function sessionToMarkdown(s, events) {
+  const out = [];
+  out.push(`# ${s.title || "Session " + s.id.slice(0, 8)}`);
+  out.push("");
+  const meta = [
+    ["Session", s.id],
+    ["Source", s.source],
+    ["Project", s.project],
+    ["Model", s.model],
+    ["Started", s.started_at],
+    ["Ended", s.ended_at]
+  ].filter(([, v]) => v);
+  for (const [k, v] of meta)
+    out.push(`- **${k}:** ${v}`);
+  out.push("");
+  out.push("---");
+  out.push("");
+  for (const e of events) {
+    const who = e.role || e.type;
+    const ts = e.timestamp ? ` _(${e.timestamp})_` : "";
+    if (e.thinking) {
+      out.push(`### \u{1F9E0} thinking${ts}`);
+      out.push("");
+      out.push(fence(e.thinking));
+      out.push("");
+    }
+    if (e.text) {
+      const icon = who === "user" ? "\u{1F464}" : who === "assistant" ? "\u{1F916}" : "\u2699\uFE0F";
+      out.push(`### ${icon} ${who}${ts}`);
+      out.push("");
+      out.push(fence(e.text));
+      out.push("");
+    }
+    for (const tc of e.toolCalls) {
+      const label = tc.skill_name ? `Skill: ${tc.skill_name}` : tc.agent_type ? `${tc.tool_name} \u2192 ${tc.agent_type}` : tc.tool_name;
+      const status = tc.status ? ` _(${tc.status})_` : "";
+      out.push(`> \u{1F527} **${label}**${status}`);
+      if (tc.input_json && tc.input_json !== "{}") {
+        out.push("```json");
+        out.push(fence(tc.input_json));
+        out.push("```");
+      }
+      out.push("");
+    }
+  }
+  return out.join("\n");
+}
+
+// ../core/dist/rawjson.js
+import { gzipSync, gunzipSync } from "zlib";
+function packRaw(json) {
+  return gzipSync(Buffer.from(json, "utf8"));
+}
+function unpackRaw(value) {
+  if (Buffer.isBuffer(value)) {
+    if (value.length >= 2 && value[0] === 31 && value[1] === 139) {
+      return gunzipSync(value).toString("utf8");
+    }
+    return value.toString("utf8");
+  }
+  return value;
+}
+
+// ../core/dist/paths.js
+import { existsSync, readFileSync } from "fs";
+import { dirname, join, resolve } from "path";
+import { fileURLToPath } from "url";
+import { homedir, platform } from "os";
+function expandPath(p) {
+  if (!p)
+    return p;
+  let out = p;
+  if (out === "~")
+    out = homedir();
+  else if (out.startsWith("~/"))
+    out = join(homedir(), out.slice(2));
+  out = out.replace(/\$HOME/g, homedir());
+  return resolve(out);
+}
+var moduleDir = dirname(fileURLToPath(import.meta.url));
+function findRepoRoot(from = moduleDir) {
+  let dir = resolve(from);
+  for (; ; ) {
+    if (existsSync(join(dir, "pnpm-workspace.yaml"))) {
+      try {
+        const pkg = JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));
+        if (pkg?.name === "agent-lens")
+          return dir;
+      } catch {
+      }
+    }
+    const parent = dirname(dir);
+    if (parent === dir)
+      return null;
+    dir = parent;
+  }
+}
+function userDataDir() {
+  const home = homedir();
+  if (platform() === "win32") {
+    return join(process.env.LOCALAPPDATA || join(home, "AppData", "Local"), "agent-lens");
+  }
+  if (platform() === "darwin") {
+    return join(home, "Library", "Application Support", "agent-lens");
+  }
+  return join(process.env.XDG_DATA_HOME || join(home, ".local", "share"), "agent-lens");
+}
+function resolveDataDir(repoRoot = findRepoRoot()) {
+  if (process.env.AGENT_LENS_DATA)
+    return resolve(process.env.AGENT_LENS_DATA);
+  if (repoRoot)
+    return join(repoRoot, "data");
+  return userDataDir();
+}
+function resolveConfigFile(repoRoot, dataDir) {
+  const candidates = [
+    process.env.AGENT_LENS_CONFIG,
+    join(dataDir, "agent-lens.config.json"),
+    repoRoot ? join(repoRoot, "agent-lens.config.json") : null,
+    repoRoot ? join(repoRoot, "agent-lens.config.example.json") : null
+  ].filter((x) => Boolean(x));
+  for (const f of candidates)
+    if (existsSync(f))
+      return f;
+  return null;
+}
+function resolveWebDist(fromDir, repoRoot = findRepoRoot(fromDir)) {
+  const installed = resolve(fromDir, "../web");
+  if (existsSync(installed))
+    return installed;
+  const devSibling = resolve(fromDir, "../../web/dist");
+  if (existsSync(devSibling))
+    return devSibling;
+  if (repoRoot)
+    return join(repoRoot, "packages/web/dist");
+  return installed;
+}
+
+// ../core/dist/sources.js
+import { readFileSync as readFileSync2 } from "fs";
+function readConfig() {
+  const repoRoot = findRepoRoot();
+  const dataDir = resolveDataDir(repoRoot);
+  const file = resolveConfigFile(repoRoot, dataDir);
+  return file ? JSON.parse(readFileSync2(file, "utf8")) : null;
+}
+function loadSources() {
+  if (process.env.CLAUDE_DIR) {
+    return [
+      {
+        label: process.env.AGENT_LENS_LABEL || "default",
+        agent: "claude-code",
+        configDir: expandPath(process.env.CLAUDE_DIR)
+      }
+    ];
+  }
+  const cfg = readConfig() ?? { sources: [{ label: "default", agent: "claude-code", configDir: "$HOME/.claude" }] };
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const raw of cfg.sources || []) {
+    const s = raw;
+    if (!s || !s.label || !s.configDir)
+      continue;
+    if (seen.has(s.label))
+      throw new Error(`duplicate source label: ${s.label}`);
+    seen.add(s.label);
+    out.push({ label: s.label, agent: s.agent || "claude-code", configDir: expandPath(s.configDir) });
+  }
+  if (!out.length)
+    throw new Error("no valid sources configured");
+  return out;
+}
+function loadExcludes() {
+  const fromEnv = (process.env.AGENT_LENS_EXCLUDE || "").split(",");
+  let fromCfg = [];
+  if (!process.env.CLAUDE_DIR) {
+    const cfg = readConfig();
+    if (cfg && Array.isArray(cfg.exclude))
+      fromCfg = cfg.exclude;
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const p of [...fromCfg, ...fromEnv]) {
+    const e = expandPath(String(p ?? "").trim());
+    if (e && !seen.has(e)) {
+      seen.add(e);
+      out.push(e);
+    }
+  }
+  return out;
+}
+
+// ../core/dist/projects.js
+function encodeProjectPath(p) {
+  return p.replace(/[/.]/g, "-").replace(/-+$/, "");
+}
+
+// ../core/dist/collect.js
+import { appendFileSync, closeSync, copyFileSync, existsSync as existsSync2, mkdirSync, openSync, readSync, readdirSync, statSync, unlinkSync, utimesSync, writeSync, chmodSync } from "fs";
+import { basename, dirname as dirname2, join as join2, relative, sep } from "path";
+import { platform as platform2 } from "os";
+var POSIX = platform2() !== "win32";
+var DIR_MODE = 448;
+var FILE_MODE = 384;
+var CHUNK = 1 << 16;
+function collectTimestamp(d = /* @__PURE__ */ new Date()) {
+  const p = (n, w = 2) => String(n).padStart(w, "0");
+  return `${d.getFullYear()}${p(d.getMonth() + 1)}${p(d.getDate())}T${p(d.getHours())}${p(d.getMinutes())}${p(d.getSeconds())}${p(d.getMilliseconds(), 3)}`;
+}
+function ensureDir(dir) {
+  mkdirSync(dir, { recursive: true, mode: DIR_MODE });
+}
+function syncMeta(dst, src) {
+  if (POSIX) {
+    try {
+      chmodSync(dst, FILE_MODE);
+    } catch {
+    }
+  }
+  try {
+    utimesSync(dst, src.atime, src.mtime);
+  } catch {
+  }
+}
+function copyWhole(src, dst, srcStat) {
+  ensureDir(dirname2(dst));
+  copyFileSync(src, dst);
+  syncMeta(dst, srcStat);
+}
+function prefixEquals(src, arc, len) {
+  const sf = openSync(src, "r");
+  const af = openSync(arc, "r");
+  try {
+    const sb = Buffer.allocUnsafe(CHUNK);
+    const ab = Buffer.allocUnsafe(CHUNK);
+    let remaining = len;
+    while (remaining > 0) {
+      const want = Math.min(CHUNK, remaining);
+      const sr = readSync(sf, sb, 0, want, null);
+      const ar = readSync(af, ab, 0, want, null);
+      if (sr !== ar || sr === 0)
+        return false;
+      if (Buffer.compare(sb.subarray(0, sr), ab.subarray(0, sr)) !== 0)
+        return false;
+      remaining -= sr;
+    }
+    return remaining === 0;
+  } finally {
+    closeSync(sf);
+    closeSync(af);
+  }
+}
+function appendRange(src, arc, from, to) {
+  const sf = openSync(src, "r");
+  const af = openSync(arc, "a");
+  try {
+    const b = Buffer.allocUnsafe(CHUNK);
+    let pos = from;
+    while (pos < to) {
+      const want = Math.min(CHUNK, to - pos);
+      const r = readSync(sf, b, 0, want, pos);
+      if (r === 0)
+        break;
+      writeSync(af, b, 0, r);
+      pos += r;
+    }
+  } finally {
+    closeSync(sf);
+    closeSync(af);
+  }
+}
+function filesEqual(a, b) {
+  const sa = statSync(a);
+  const sb = statSync(b);
+  if (sa.size !== sb.size)
+    return false;
+  return prefixEquals(a, b, sa.size);
+}
+function latestSnapshot(archive, relParts) {
+  const versRoot = join2(archive, ".versions");
+  if (!existsSync2(versRoot))
+    return null;
+  const stamps = readdirSync(versRoot).sort();
+  for (let i = stamps.length - 1; i >= 0; i--) {
+    const p = join2(versRoot, stamps[i], ...relParts);
+    if (existsSync2(p))
+      return p;
+  }
+  return null;
+}
+function snapshot(absPath, relParts, versionsDir, stats) {
+  const dst = join2(versionsDir, ...relParts);
+  ensureDir(dirname2(dst));
+  copyFileSync(absPath, dst);
+  syncMeta(dst, statSync(absPath));
+  stats.snapshots++;
+}
+function walkJsonl(dir, out) {
+  for (const e of readdirSync(dir, { withFileTypes: true })) {
+    const p = join2(dir, e.name);
+    if (e.isDirectory())
+      walkJsonl(p, out);
+    else if (e.isFile() && e.name.endsWith(".jsonl"))
+      out.push(p);
+  }
+}
+function syncFile(src, dst, relParts, archive, versionsDir, stats) {
+  const srcStat = statSync(src);
+  if (!existsSync2(dst)) {
+    copyWhole(src, dst, srcStat);
+    stats.copied++;
+    return;
+  }
+  const arcStat = statSync(dst);
+  if (srcStat.size === arcStat.size && Math.trunc(srcStat.mtimeMs) === Math.trunc(arcStat.mtimeMs))
+    return;
+  const ssize = srcStat.size;
+  const asize = arcStat.size;
+  if (ssize >= asize && prefixEquals(src, dst, asize)) {
+    if (ssize > asize) {
+      appendRange(src, dst, asize, ssize);
+      stats.appended++;
+    }
+    syncMeta(dst, srcStat);
+  } else if (ssize < asize) {
+    const last = latestSnapshot(archive, relParts);
+    if (!last || !filesEqual(last, src))
+      snapshot(src, relParts, versionsDir, stats);
+    stats.compacted++;
+  } else {
+    snapshot(dst, relParts, versionsDir, stats);
+    copyWhole(src, dst, srcStat);
+    stats.diverged++;
+  }
+}
+function removeCredentials(dir) {
+  if (!existsSync2(dir))
+    return;
+  for (const e of readdirSync(dir, { withFileTypes: true })) {
+    const p = join2(dir, e.name);
+    if (e.isDirectory())
+      removeCredentials(p);
+    else if (e.name === ".credentials.json") {
+      try {
+        unlinkSync(p);
+      } catch {
+      }
+    }
+  }
+}
+function collectSource(source, archiveBase, excludedDirs, runTs, stats, log) {
+  const { label, configDir } = source;
+  const archive = join2(archiveBase, label);
+  const versionsDir = join2(archive, ".versions", runTs);
+  if (!existsSync2(configDir)) {
+    log(`agent-lens: [${label}] source not found: ${configDir} (skipping)`);
+    return;
+  }
+  ensureDir(join2(archive, "projects"));
+  ensureDir(join2(archive, "settings"));
+  const files = [];
+  const projectsDir = join2(configDir, "projects");
+  if (existsSync2(projectsDir))
+    walkJsonl(projectsDir, files);
+  const historySrc = join2(configDir, "history.jsonl");
+  if (existsSync2(historySrc))
+    files.push(historySrc);
+  const before = { scanned: stats.scanned, snapshots: stats.snapshots };
+  for (const src of files) {
+    const base = basename(src);
+    if (base === ".credentials.json" || base.endsWith(".lock"))
+      continue;
+    const relParts = relative(configDir, src).split(sep);
+    const relPosix = relParts.join("/");
+    if (excludedDirs.some((enc) => relPosix.startsWith(`projects/${enc}/`)))
+      continue;
+    stats.scanned++;
+    syncFile(src, join2(archive, ...relParts), relParts, archive, versionsDir, stats);
+  }
+  for (const f of ["settings.json", "settings.local.json"]) {
+    const s = join2(configDir, f);
+    if (!existsSync2(s))
+      continue;
+    const a = join2(archive, "settings", f);
+    if (existsSync2(a) && !filesEqual(s, a))
+      snapshot(a, ["settings", f], versionsDir, stats);
+    ensureDir(dirname2(a));
+    copyFileSync(s, a);
+    syncMeta(a, statSync(s));
+  }
+  removeCredentials(archive);
+  const scanned = stats.scanned - before.scanned;
+  const snapshots = stats.snapshots - before.snapshots;
+  const line = `${(/* @__PURE__ */ new Date()).toISOString()} run=${runTs} source=${label} scanned=${scanned} snapshots=${snapshots} archive=${archive}`;
+  log(`agent-lens: ${line}`);
+  try {
+    appendFileSync(join2(archiveBase, ".collect.log"), line + "\n");
+  } catch {
+  }
+}
+function collectAll(opts = {}) {
+  const log = opts.log ?? ((m) => console.log(m));
+  const archiveBase = opts.archiveBase ?? join2(resolveDataDir(findRepoRoot()), "archive");
+  const sources = opts.sources ?? loadSources();
+  const excludedDirs = (opts.excludes ?? loadExcludes()).map(encodeProjectPath);
+  const runTs = opts.runTimestamp ?? collectTimestamp();
+  ensureDir(archiveBase);
+  const stats = { sources: 0, scanned: 0, copied: 0, appended: 0, diverged: 0, compacted: 0, snapshots: 0 };
+  if (!sources.length)
+    throw new Error("no sources configured");
+  for (const source of sources) {
+    stats.sources++;
+    collectSource(source, archiveBase, excludedDirs, runTs, stats, log);
+  }
+  return stats;
+}
+
+// ../core/dist/lock.js
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, unlinkSync as unlinkSync2, writeFileSync } from "fs";
+import { dirname as dirname3 } from "path";
+import { hostname } from "os";
+function isAlive(pid) {
+  if (!pid)
+    return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    return e.code === "EPERM";
+  }
+}
+function acquireLock(lockPath, staleMs = 6 * 60 * 60 * 1e3) {
+  mkdirSync2(dirname3(lockPath), { recursive: true });
+  if (existsSync3(lockPath)) {
+    try {
+      const held = JSON.parse(readFileSync3(lockPath, "utf8"));
+      const fresh = typeof held.ts === "number" && Date.now() - held.ts < staleMs;
+      if (fresh && isAlive(held.pid ?? 0))
+        return null;
+    } catch {
+    }
+  }
+  writeFileSync(lockPath, JSON.stringify({ pid: process.pid, ts: Date.now(), host: hostname() }), { mode: 384 });
+  let released = false;
+  const release = () => {
+    if (released)
+      return;
+    released = true;
+    try {
+      const cur = JSON.parse(readFileSync3(lockPath, "utf8"));
+      if (cur.pid === process.pid)
+        unlinkSync2(lockPath);
+    } catch {
+    }
+  };
+  process.once("exit", release);
+  return { release };
+}
+
+// ../core/dist/service.js
+import { spawnSync } from "child_process";
+import { mkdirSync as mkdirSync3, rmSync, writeFileSync as writeFileSync2 } from "fs";
+import { homedir as homedir2, platform as platform3 } from "os";
+import { join as join3 } from "path";
+var DEFAULT_HOURS = [9, 13, 17, 21];
+var SYSTEMD_COLLECTOR_TIMER = "agent-lens-collect.timer";
+var SYSTEMD_COLLECTOR_SERVICE = "agent-lens-collect.service";
+var SYSTEMD_SERVER_SERVICE = "agent-lens-server.service";
+var LAUNCHD_COLLECTOR_LABEL = "org.agent-lens.collect";
+var LAUNCHD_SERVER_LABEL = "org.agent-lens.server";
+var WINDOWS_COLLECTOR_PREFIX = "AgentLens\\Collect";
+var WINDOWS_SERVER_TASK = "AgentLens\\Server";
+function parseTargets(spec) {
+  if (!spec || spec === "all")
+    return ["collector", "server"];
+  if (spec === "collector" || spec === "server")
+    return [spec];
+  throw new Error(`invalid target '${spec}' (expected: collector | server | all)`);
+}
+function parseHours(spec) {
+  if (!spec)
+    return DEFAULT_HOURS;
+  const hours = spec.split(",").map((s) => Number.parseInt(s.trim(), 10)).filter((n) => Number.isInteger(n) && n >= 0 && n <= 23);
+  if (!hours.length)
+    throw new Error(`invalid hours '${spec}' (expected comma-separated 0-23, e.g. 9,13,17,21)`);
+  return [...new Set(hours)].sort((a, b) => a - b);
+}
+function serverEnv() {
+  const env = {};
+  if (process.env.AGENT_LENS_PORT)
+    env.AGENT_LENS_PORT = process.env.AGENT_LENS_PORT;
+  if (process.env.AGENT_LENS_HOST)
+    env.AGENT_LENS_HOST = process.env.AGENT_LENS_HOST;
+  return env;
+}
+function onCalendarHours(hours) {
+  return hours.map((h) => String(h).padStart(2, "0")).join(",") + ":00";
+}
+function systemdCollectorService(node, cli2) {
+  return `[Unit]
+Description=Agent Lens \u2014 collect + ingest Claude Code session traces
+
+[Service]
+Type=oneshot
+# Absolute node + CLI paths: systemd user services don't inherit the interactive PATH.
+ExecStart=${node} ${cli2} collect --then-ingest
+Nice=10
+IOSchedulingClass=idle
+`;
+}
+function systemdCollectorTimer(hours) {
+  return `[Unit]
+Description=Agent Lens \u2014 periodic Claude Code trace collection
+
+[Timer]
+# A few times a day. Persistent catches runs missed while the machine was off.
+OnCalendar=*-*-* ${onCalendarHours(hours)}
+Persistent=true
+RandomizedDelaySec=300
+
+[Install]
+WantedBy=timers.target
+`;
+}
+function systemdServerService(node, cli2, env = {}) {
+  const envLines = Object.entries(env).map(([k, v]) => `Environment=${k}=${v}
+`).join("");
+  return `[Unit]
+Description=Agent Lens \u2014 local web UI + read-only API server
+After=network.target
+
+[Service]
+Type=simple
+# Absolute node + CLI paths: systemd user services don't inherit the interactive PATH.
+ExecStart=${node} ${cli2} serve
+${envLines}# Long-running: restart if it crashes.
+Restart=on-failure
+RestartSec=5
+Nice=10
+
+[Install]
+WantedBy=default.target
+`;
+}
+function launchdCollectorPlist(node, cli2, hours, logPath) {
+  const cal = hours.map((h) => `    <dict><key>Hour</key><integer>${h}</integer><key>Minute</key><integer>0</integer></dict>`).join("\n");
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key><string>${LAUNCHD_COLLECTOR_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${node}</string>
+    <string>${cli2}</string>
+    <string>collect</string>
+    <string>--then-ingest</string>
+  </array>
+  <key>StartCalendarInterval</key>
+  <array>
+${cal}
+  </array>
+  <key>StandardOutPath</key><string>${logPath}</string>
+  <key>StandardErrorPath</key><string>${logPath}</string>
+</dict>
+</plist>
+`;
+}
+function launchdServerPlist(node, cli2, logPath, env = {}) {
+  const envDict = Object.entries(env).length ? `  <key>EnvironmentVariables</key>
+  <dict>
+${Object.entries(env).map(([k, v]) => `    <key>${k}</key><string>${v}</string>`).join("\n")}
+  </dict>
+` : "";
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key><string>${LAUNCHD_SERVER_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${node}</string>
+    <string>${cli2}</string>
+    <string>serve</string>
+  </array>
+${envDict}  <key>RunAtLoad</key><true/>
+  <key>KeepAlive</key><true/>
+  <key>StandardOutPath</key><string>${logPath}</string>
+  <key>StandardErrorPath</key><string>${logPath}</string>
+</dict>
+</plist>
+`;
+}
+function sh(cmd, args, quiet = false) {
+  const r = spawnSync(cmd, args, { stdio: quiet ? "ignore" : "inherit", encoding: "utf8" });
+  return r.status === 0;
+}
+function have(cmd) {
+  const r = spawnSync(cmd, ["--version"], { stdio: "ignore" });
+  return r.status === 0 || r.error === void 0;
+}
+function systemdUnitDir() {
+  return join3(process.env.XDG_CONFIG_HOME || join3(homedir2(), ".config"), "systemd", "user");
+}
+function linuxInstall(targets, node, cli2, hours) {
+  if (!have("systemctl")) {
+    console.error("agent-lens service: systemctl not found \u2014 is this a systemd system?");
+    process.exitCode = 1;
+    return;
+  }
+  const dir = systemdUnitDir();
+  mkdirSync3(dir, { recursive: true });
+  if (targets.includes("collector")) {
+    writeFileSync2(join3(dir, SYSTEMD_COLLECTOR_SERVICE), systemdCollectorService(node, cli2));
+    writeFileSync2(join3(dir, SYSTEMD_COLLECTOR_TIMER), systemdCollectorTimer(hours));
+  }
+  if (targets.includes("server")) {
+    writeFileSync2(join3(dir, SYSTEMD_SERVER_SERVICE), systemdServerService(node, cli2, serverEnv()));
+  }
+  sh("systemctl", ["--user", "daemon-reload"]);
+  if (targets.includes("collector")) {
+    sh("systemctl", ["--user", "enable", "--now", SYSTEMD_COLLECTOR_TIMER]);
+    console.log(`agent-lens service: installed collector timer (${onCalendarHours(hours)})`);
+    sh("systemctl", ["--user", "list-timers", SYSTEMD_COLLECTOR_TIMER, "--no-pager"]);
+  }
+  if (targets.includes("server")) {
+    sh("systemctl", ["--user", "enable", "--now", SYSTEMD_SERVER_SERVICE]);
+    console.log("agent-lens service: installed server daemon");
+    sh("systemctl", ["--user", "status", SYSTEMD_SERVER_SERVICE, "--no-pager"]);
+  }
+  if (have("loginctl") && !sh("loginctl", ["enable-linger", process.env.USER || ""], true)) {
+    console.log(`agent-lens: could not enable linger automatically; run: sudo loginctl enable-linger ${process.env.USER}`);
+  }
+}
+function linuxUninstall(targets) {
+  if (!have("systemctl"))
+    return;
+  const dir = systemdUnitDir();
+  if (targets.includes("collector")) {
+    sh("systemctl", ["--user", "disable", "--now", SYSTEMD_COLLECTOR_TIMER], true);
+    for (const u of [SYSTEMD_COLLECTOR_TIMER, SYSTEMD_COLLECTOR_SERVICE])
+      rmSync(join3(dir, u), { force: true });
+    sh("systemctl", ["--user", "reset-failed", SYSTEMD_COLLECTOR_SERVICE], true);
+  }
+  if (targets.includes("server")) {
+    sh("systemctl", ["--user", "disable", "--now", SYSTEMD_SERVER_SERVICE], true);
+    rmSync(join3(dir, SYSTEMD_SERVER_SERVICE), { force: true });
+    sh("systemctl", ["--user", "reset-failed", SYSTEMD_SERVER_SERVICE], true);
+  }
+  sh("systemctl", ["--user", "daemon-reload"]);
+  console.log("agent-lens service: uninstalled (archive untouched)");
+}
+function linuxStatus(targets) {
+  if (!have("systemctl"))
+    return;
+  if (targets.includes("collector"))
+    sh("systemctl", ["--user", "list-timers", SYSTEMD_COLLECTOR_TIMER, "--no-pager"]);
+  if (targets.includes("server"))
+    sh("systemctl", ["--user", "status", SYSTEMD_SERVER_SERVICE, "--no-pager"]);
+}
+function launchdPlistPath(label) {
+  return join3(homedir2(), "Library", "LaunchAgents", `${label}.plist`);
+}
+function macBootstrap(plist) {
+  const uid = typeof process.getuid === "function" ? process.getuid() : 0;
+  if (!sh("launchctl", ["bootstrap", `gui/${uid}`, plist], true))
+    sh("launchctl", ["load", "-w", plist]);
+}
+function macBootout(label, plist) {
+  const uid = typeof process.getuid === "function" ? process.getuid() : 0;
+  if (!sh("launchctl", ["bootout", `gui/${uid}/${label}`], true))
+    sh("launchctl", ["unload", "-w", plist], true);
+  rmSync(plist, { force: true });
+}
+function macInstall(targets, node, cli2, hours) {
+  const agents = join3(homedir2(), "Library", "LaunchAgents");
+  mkdirSync3(agents, { recursive: true });
+  const dataDir = resolveDataDir(findRepoRoot());
+  if (targets.includes("collector")) {
+    const plist = launchdPlistPath(LAUNCHD_COLLECTOR_LABEL);
+    writeFileSync2(plist, launchdCollectorPlist(node, cli2, hours, join3(dataDir, "schedule.log")));
+    macBootstrap(plist);
+    console.log(`agent-lens service: installed collector agent ${LAUNCHD_COLLECTOR_LABEL} (hours ${hours.join(",")})`);
+  }
+  if (targets.includes("server")) {
+    const plist = launchdPlistPath(LAUNCHD_SERVER_LABEL);
+    writeFileSync2(plist, launchdServerPlist(node, cli2, join3(dataDir, "server.log"), serverEnv()));
+    macBootstrap(plist);
+    console.log(`agent-lens service: installed server agent ${LAUNCHD_SERVER_LABEL}`);
+  }
+}
+function macUninstall(targets) {
+  if (targets.includes("collector"))
+    macBootout(LAUNCHD_COLLECTOR_LABEL, launchdPlistPath(LAUNCHD_COLLECTOR_LABEL));
+  if (targets.includes("server"))
+    macBootout(LAUNCHD_SERVER_LABEL, launchdPlistPath(LAUNCHD_SERVER_LABEL));
+  console.log("agent-lens service: uninstalled (archive untouched)");
+}
+function macStatus(targets) {
+  const uid = typeof process.getuid === "function" ? process.getuid() : 0;
+  if (targets.includes("collector"))
+    sh("launchctl", ["print", `gui/${uid}/${LAUNCHD_COLLECTOR_LABEL}`]);
+  if (targets.includes("server"))
+    sh("launchctl", ["print", `gui/${uid}/${LAUNCHD_SERVER_LABEL}`]);
+}
+function winCollectorTaskName(hour) {
+  return `${WINDOWS_COLLECTOR_PREFIX}_${String(hour).padStart(2, "0")}`;
+}
+function windowsInstall(targets, node, cli2, hours) {
+  if (targets.includes("collector")) {
+    const tr = `"${node}" "${cli2}" collect --then-ingest`;
+    for (const h of hours) {
+      sh("schtasks", ["/Create", "/F", "/TN", winCollectorTaskName(h), "/TR", tr, "/SC", "DAILY", "/ST", `${String(h).padStart(2, "0")}:00`]);
+    }
+    console.log(`agent-lens service: installed ${hours.length} collector task(s) (hours ${hours.join(",")})`);
+  }
+  if (targets.includes("server")) {
+    const tr = `"${node}" "${cli2}" serve`;
+    sh("schtasks", ["/Create", "/F", "/TN", WINDOWS_SERVER_TASK, "/TR", tr, "/SC", "ONLOGON", "/RL", "LIMITED"]);
+    console.log("agent-lens service: installed server task (starts at logon)");
+  }
+}
+function windowsUninstall(targets) {
+  if (targets.includes("collector")) {
+    for (let h = 0; h < 24; h++)
+      sh("schtasks", ["/Delete", "/F", "/TN", winCollectorTaskName(h)], true);
+  }
+  if (targets.includes("server"))
+    sh("schtasks", ["/Delete", "/F", "/TN", WINDOWS_SERVER_TASK], true);
+  console.log("agent-lens service: uninstalled (archive untouched)");
+}
+function windowsStatus(targets) {
+  if (targets.includes("collector")) {
+    sh("schtasks", ["/Query", "/FO", "LIST", "/TN", WINDOWS_COLLECTOR_PREFIX], true) || console.log("agent-lens service: no collector tasks found under " + WINDOWS_COLLECTOR_PREFIX);
+  }
+  if (targets.includes("server")) {
+    sh("schtasks", ["/Query", "/FO", "LIST", "/TN", WINDOWS_SERVER_TASK], true) || console.log("agent-lens service: no server task found (" + WINDOWS_SERVER_TASK + ")");
+  }
+}
+function runService(action, params) {
+  const node = params.node ?? process.execPath;
+  const cli2 = params.cliEntry;
+  const hours = params.hours ?? DEFAULT_HOURS;
+  const targets = params.targets;
+  const plat = platform3();
+  const impl = plat === "linux" ? {
+    install: () => linuxInstall(targets, node, cli2, hours),
+    uninstall: () => linuxUninstall(targets),
+    status: () => linuxStatus(targets)
+  } : plat === "darwin" ? {
+    install: () => macInstall(targets, node, cli2, hours),
+    uninstall: () => macUninstall(targets),
+    status: () => macStatus(targets)
+  } : plat === "win32" ? {
+    install: () => windowsInstall(targets, node, cli2, hours),
+    uninstall: () => windowsUninstall(targets),
+    status: () => windowsStatus(targets)
+  } : null;
+  if (!impl) {
+    console.error(`agent-lens service: unsupported platform '${plat}'`);
+    process.exitCode = 1;
+    return;
+  }
+  if (action === "install")
+    impl.install();
+  else if (action === "uninstall")
+    impl.uninstall();
+  else if (action === "status")
+    impl.status();
+  else {
+    console.error(`agent-lens service: unknown action '${action}' (use: install | uninstall | status)`);
+    process.exitCode = 1;
+  }
+}
+
+// ../ingest/dist/run.js
+import { readFileSync as readFileSync4, statSync as statSync2, mkdirSync as mkdirSync4, existsSync as existsSync4 } from "fs";
+import { dirname as dirname4, join as join5 } from "path";
+
+// ../ingest/dist/db.js
+import Database from "better-sqlite3";
+function openRaw(file) {
+  const db = new Database(file);
+  db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
+  return db;
+}
+function applySchema(db) {
+  db.exec(SCHEMA_SQL);
+  db.prepare("INSERT INTO meta(key, value) VALUES ('schema_version', ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value").run(String(SCHEMA_VERSION));
+}
+function openDb(file) {
+  const db = openRaw(file);
+  applySchema(db);
+  return db;
+}
+function resetSchema(db) {
+  db.pragma("foreign_keys = OFF");
+  db.exec(`
+    DROP TRIGGER IF EXISTS events_au;
+    DROP TRIGGER IF EXISTS events_ad;
+    DROP TRIGGER IF EXISTS events_ai;
+    DROP TABLE IF EXISTS events_fts;
+    DROP TABLE IF EXISTS classifications;
+    DROP TABLE IF EXISTS token_usage;
+    DROP TABLE IF EXISTS tool_calls;
+    DROP TABLE IF EXISTS skills;
+    DROP TABLE IF EXISTS events;
+    DROP TABLE IF EXISTS turns;
+    DROP TABLE IF EXISTS sessions;
+    DROP TABLE IF EXISTS projects;
+    DROP TABLE IF EXISTS sources;
+    DROP TABLE IF EXISTS agents;
+    DROP TABLE IF EXISTS ingest_state;
+    DROP TABLE IF EXISTS meta;
+  `);
+  applySchema(db);
+  db.pragma("foreign_keys = ON");
+}
+
+// ../ingest/dist/adapters/claude-code.js
+import { readdirSync as readdirSync2 } from "fs";
+import { basename as basename2, join as join4 } from "path";
+function flattenText(content) {
+  if (content == null)
+    return null;
+  if (typeof content === "string")
+    return content.trim() || null;
+  if (!Array.isArray(content))
+    return null;
+  const parts = [];
+  for (const block of content) {
+    if (!block || typeof block !== "object")
+      continue;
+    const b = block;
+    if (b.type === "text" && typeof b.text === "string")
+      parts.push(b.text);
+    else if (b.type === "thinking" && typeof b.thinking === "string")
+      parts.push(b.thinking);
+  }
+  const text = parts.join("\n").trim();
+  return text || null;
+}
+function summarizeResult(content) {
+  let s = null;
+  if (typeof content === "string")
+    s = content;
+  else if (Array.isArray(content)) {
+    const parts = [];
+    for (const block of content) {
+      const b = block;
+      if (b && b.type === "text" && typeof b.text === "string")
+        parts.push(b.text);
+    }
+    s = parts.join("\n");
+  } else if (content != null) {
+    s = JSON.stringify(content);
+  }
+  if (!s)
+    return null;
+  s = s.replace(/\s+/g, " ").trim();
+  return s.slice(0, 280) || null;
+}
+function asString(v) {
+  return typeof v === "string" && v.length > 0 ? v : null;
+}
+function asInt(v) {
+  return typeof v === "number" && Number.isFinite(v) ? Math.trunc(v) : 0;
+}
+function parentSessionFromPath(path) {
+  const parts = path.split("/");
+  const i = parts.indexOf("subagents");
+  return i > 0 ? parts[i - 1] : null;
+}
+function workflowRunFromPath(path) {
+  const parts = path.split("/");
+  const i = parts.indexOf("workflows");
+  return i >= 0 && i + 1 < parts.length ? parts[i + 1] : null;
+}
+function recurseJsonl(dir, out) {
+  let entries;
+  try {
+    entries = readdirSync2(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const e of entries) {
+    const p = join4(dir, e.name);
+    if (e.isDirectory())
+      recurseJsonl(p, out);
+    else if (e.isFile() && e.name.endsWith(".jsonl"))
+      out.push(p);
+  }
+}
+var ClaudeCodeAdapter = class {
+  agentId = "claude-code";
+  agentName = "Claude Code CLI";
+  discover(sourceArchiveDir, sourceId) {
+    const files = [];
+    const archiveRoot = sourceArchiveDir;
+    const addFrom = (projectsDir, isVersion) => {
+      const found = [];
+      recurseJsonl(projectsDir, found);
+      for (const path of found) {
+        const parts = path.split("/");
+        const sessionId = basename2(path, ".jsonl");
+        const encodedDir = parts[parts.length - 2] ?? "";
+        files.push({
+          path,
+          sessionId,
+          encodedDir,
+          isVersion,
+          sourceId,
+          parentSessionId: parentSessionFromPath(path),
+          workflowRunId: workflowRunFromPath(path)
+        });
+      }
+    };
+    addFrom(join4(archiveRoot, "projects"), false);
+    const versionsRoot = join4(archiveRoot, ".versions");
+    try {
+      for (const ts of readdirSync2(versionsRoot, { withFileTypes: true })) {
+        if (ts.isDirectory())
+          addFrom(join4(versionsRoot, ts.name, "projects"), true);
+      }
+    } catch {
+    }
+    return files;
+  }
+  parseLine(raw, file, seq) {
+    if (!raw || typeof raw !== "object")
+      return {};
+    const r = raw;
+    const meta = {};
+    if (asString(r.cwd))
+      meta.cwd = r.cwd;
+    if (asString(r.slug))
+      meta.slug = r.slug;
+    if (asString(r.version))
+      meta.cli_version = r.version;
+    if (asString(r.entrypoint))
+      meta.entrypoint = r.entrypoint;
+    if (asString(r.gitBranch))
+      meta.git_branch = r.gitBranch;
+    if (typeof r.isSidechain === "boolean")
+      meta.is_sidechain = r.isSidechain;
+    if (r.type === "ai-title" && asString(r.aiTitle))
+      meta.ai_title = r.aiTitle;
+    if (!asString(r.uuid))
+      return { meta };
+    const message = r.message ?? {};
+    const text = flattenText(message.content);
+    const result = {
+      meta,
+      event: {
+        uuid: r.uuid,
+        session_id: file.sessionId,
+        turn_id: null,
+        parent_uuid: asString(r.parentUuid),
+        seq,
+        type: asString(r.type) ?? "unknown",
+        role: asString(message.role),
+        timestamp: asString(r.timestamp),
+        model: asString(message.model),
+        is_sidechain: r.isSidechain ? 1 : 0,
+        is_meta: r.isMeta ? 1 : 0,
+        text,
+        raw_json: JSON.stringify(raw),
+        source_file: file.path
+      }
+    };
+    const usage = message.usage;
+    if (usage) {
+      result.tokenUsage = {
+        event_uuid: r.uuid,
+        session_id: file.sessionId,
+        turn_id: null,
+        message_id: asString(message.id),
+        model: asString(message.model),
+        input_tokens: asInt(usage.input_tokens),
+        output_tokens: asInt(usage.output_tokens),
+        cache_creation_input_tokens: asInt(usage.cache_creation_input_tokens),
+        cache_read_input_tokens: asInt(usage.cache_read_input_tokens),
+        service_tier: asString(usage.service_tier)
+      };
+    }
+    const content = message.content;
+    if (Array.isArray(content)) {
+      const toolCalls = [];
+      const toolResults = [];
+      const tur = r.toolUseResult;
+      for (const block of content) {
+        if (!block || typeof block !== "object")
+          continue;
+        const b = block;
+        if (b.type === "tool_use" && asString(b.id)) {
+          const name = asString(b.name) ?? "unknown";
+          const input = b.input ?? {};
+          toolCalls.push({
+            id: b.id,
+            event_uuid: r.uuid,
+            session_id: file.sessionId,
+            turn_id: null,
+            tool_name: name,
+            caller: asString(b.caller),
+            skill_name: name === "Skill" ? asString(input.skill) ?? asString(input.command) : null,
+            skill_id: null,
+            // content-addressed skill version; linked in rebuildDerived from the injected body
+            agent_type: name === "Task" || name === "Agent" ? asString(input.subagent_type) : null,
+            spawned_session_id: null,
+            // patched in once the tool_result carries toolUseResult.agentId
+            workflow_run_id: null,
+            // patched in from the Workflow tool_result's runId
+            workflow_name: name === "Workflow" ? asString(input.name) : null,
+            // refined from the result
+            resolved_model: null,
+            status: null,
+            total_duration_ms: null,
+            total_tokens: null,
+            total_tool_use_count: null,
+            input_json: JSON.stringify(input),
+            result_summary: null
+          });
+        } else if (b.type === "tool_result" && asString(b.tool_use_id)) {
+          toolResults.push({
+            tool_use_id: b.tool_use_id,
+            result_summary: summarizeResult(b.content),
+            ...tur ? {
+              status: asString(tur.status),
+              agent_type: asString(tur.agentType),
+              // Deterministic link: a Task/Agent subagent's transcript is keyed off its agentId
+              // ('agent-'||agentId is the session id assigned by discover()'s filename stem).
+              spawned_session_id: asString(tur.agentId) ? `agent-${tur.agentId}` : null,
+              // Workflow fan-out: the result carries the run id (wf_<id>) + workflow name; this is
+              // how a run's subagents (nested under subagents/workflows/<runId>/) link to this turn.
+              workflow_run_id: asString(tur.runId),
+              workflow_name: asString(tur.workflowName),
+              resolved_model: asString(tur.resolvedModel),
+              total_duration_ms: typeof tur.totalDurationMs === "number" ? tur.totalDurationMs : null,
+              total_tokens: typeof tur.totalTokens === "number" ? tur.totalTokens : null,
+              total_tool_use_count: typeof tur.totalToolUseCount === "number" ? tur.totalToolUseCount : null
+            } : {}
+          });
+        }
+      }
+      if (toolCalls.length)
+        result.toolCalls = toolCalls;
+      if (toolResults.length)
+        result.toolResults = toolResults;
+    }
+    return result;
+  }
+};
+
+// ../ingest/dist/classify.js
+var CLASSIFIER_VERSION = 2;
+var CATEGORIES = ["bugfix", "refactor", "docs", "ops", "review", "feature", "chore"];
+var BANDS = [
+  { max: 22, band: "trivial" },
+  { max: 40, band: "small" },
+  { max: 55, band: "medium" },
+  { max: 68, band: "large" },
+  { max: Infinity, band: "xl" }
+];
+var REVIEW_SUBAGENT_ROLES = /* @__PURE__ */ new Set(["Explore", "Plan", "code-reviewer", "claude-code-guide"]);
+function categoryForSubagentRole(role) {
+  if (!role)
+    return null;
+  return REVIEW_SUBAGENT_ROLES.has(role) ? "review" : null;
+}
+function countLines(s) {
+  if (!s)
+    return 0;
+  const trimmed = s.endsWith("\n") ? s.slice(0, -1) : s;
+  return trimmed.length === 0 ? 0 : trimmed.split("\n").length;
+}
+var DOC_EXT = /\.(md|markdown|rst|txt|adoc)$/i;
+var OPS_FILE = /(^|\/)(dockerfile|docker-compose|\.github\/|\.gitlab-ci|makefile)|\.(ya?ml|tf|sh|toml|ini|cfg|service|timer)$/i;
+function locDelta(toolName, inputJson) {
+  if (!inputJson)
+    return { added: 0, removed: 0, file: null };
+  let input;
+  try {
+    input = JSON.parse(inputJson);
+  } catch {
+    return { added: 0, removed: 0, file: null };
+  }
+  const file = typeof input?.file_path === "string" ? input.file_path : null;
+  if (toolName === "Write")
+    return { added: countLines(input?.content), removed: 0, file };
+  if (toolName === "Edit")
+    return { added: countLines(input?.new_string), removed: countLines(input?.old_string), file };
+  return { added: 0, removed: 0, file };
+}
+function band(score) {
+  for (const b of BANDS)
+    if (score < b.max)
+      return b.band;
+  return "xl";
+}
+var clamp01 = (x) => x < 0 ? 0 : x > 1 ? 1 : x;
+function hits(text, words) {
+  let n = 0;
+  for (const w of words) {
+    let i = text.indexOf(w);
+    while (i !== -1) {
+      n++;
+      i = text.indexOf(w, i + w.length);
+    }
+  }
+  return n;
+}
+function scoreCategories(s, text) {
+  const t = text.toLowerCase();
+  const editN = s.toolCounts["Edit"] ?? 0;
+  const writeN = s.toolCounts["Write"] ?? 0;
+  const readN = s.toolCounts["Read"] ?? 0;
+  const writes = editN + writeN;
+  const scores = {
+    bugfix: 0,
+    refactor: 0,
+    docs: 0,
+    ops: 0,
+    review: 0,
+    feature: 0,
+    chore: 0
+  };
+  scores.bugfix += hits(t, ["bug", "fix", "broken", "crash", "regression", "traceback", "stack trace", "failing", "error", "exception", "not working"]) * 1;
+  scores.refactor += hits(t, ["refactor", "clean up", "cleanup", "rename", "extract", "simplify", "dead code", "tidy", "reorganize", "restructure"]) * 1;
+  scores.docs += hits(t, ["readme", "document", "documentation", "changelog", "docstring", "comment", "write docs", "usage guide"]) * 1;
+  scores.ops += hits(t, ["deploy", "docker", "pipeline", "ci/cd", "ci ", "systemd", "infra", "kubernetes", "terraform", "release", "rollback", "container"]) * 1;
+  scores.review += hits(t, ["review", "audit", "inspect", "look over", "feedback on"]) * 1;
+  scores.feature += hits(t, ["add ", "implement", "build ", "create ", "feature", "support for", "new feature"]) * 0.8;
+  const docFiles = s.loc.files > 0 ? countMatch(s, DOC_EXT) : 0;
+  const opsFiles = s.loc.files > 0 ? countMatch(s, OPS_FILE) : 0;
+  if (s.loc.files > 0) {
+    scores.docs += 3 * (docFiles / s.loc.files);
+    scores.ops += 3 * (opsFiles / s.loc.files);
+  }
+  if (writes >= 3 && s.loc.churn > 0 && Math.abs(s.loc.net) / s.loc.churn < 0.34)
+    scores.refactor += 1.5;
+  if (editN >= 4 && editN >= writeN * 2)
+    scores.refactor += 1;
+  if (readN >= 5 && writes <= 2)
+    scores.review += 1.5;
+  if (writeN >= 1 && s.loc.net > 20)
+    scores.feature += 1.5;
+  const maxScore = Math.max(...CATEGORIES.map((c) => scores[c]));
+  if (maxScore === 0)
+    scores[writes > 0 ? "feature" : "chore"] += 0.01;
+  return scores;
+}
+function countMatch(s, re) {
+  const files = s._files ?? [];
+  let n = 0;
+  for (const f of files)
+    if (re.test(f))
+      n++;
+  return n;
+}
+function complexity(s) {
+  const weights = { loc: 0.25, files: 0.15, turns: 0.2, tokens: 0.2, duration: 0.1, subagents: 0.1 };
+  const subscores = {
+    loc: clamp01(Math.log1p(s.loc.churn) / Math.log1p(6e3)),
+    files: clamp01(s.loc.files / 40),
+    turns: clamp01(s.turn_count / 40),
+    tokens: clamp01(Math.log1p(s.work_tokens) / Math.log1p(4e7)),
+    duration: clamp01(s.duration_ms / (600 * 6e4)),
+    subagents: clamp01(s.subagent_count / 10)
+  };
+  let acc = 0;
+  for (const k of Object.keys(weights))
+    acc += weights[k] * subscores[k];
+  return { score: Math.round(acc * 1e3) / 10, subscores, weights };
+}
+function classify(db, dirty) {
+  const incremental = dirty != null;
+  if (incremental) {
+    db.exec("DROP TABLE IF EXISTS _dirty");
+    db.exec("CREATE TEMP TABLE _dirty (id TEXT PRIMARY KEY)");
+    const ins = db.prepare("INSERT OR IGNORE INTO _dirty (id) VALUES (?)");
+    db.transaction((ids) => {
+      for (const id of ids)
+        ins.run(id);
+    })(dirty);
+  }
+  const wSess = incremental ? " WHERE session_id IN (SELECT id FROM _dirty)" : "";
+  const aSess = incremental ? " AND session_id IN (SELECT id FROM _dirty)" : "";
+  const sessions = db.prepare(`SELECT id, is_sidechain, turn_count, event_count, duration_ms FROM sessions${incremental ? " WHERE id IN (SELECT id FROM _dirty)" : ""}`).all();
+  const toolMix = /* @__PURE__ */ new Map();
+  for (const r of db.prepare(`SELECT session_id, tool_name, COUNT(*) c FROM tool_calls${wSess} GROUP BY session_id, tool_name`).all()) {
+    const m = toolMix.get(r.session_id) ?? {};
+    m[r.tool_name] = r.c;
+    toolMix.set(r.session_id, m);
+  }
+  const skillMix = /* @__PURE__ */ new Map();
+  for (const r of db.prepare(`SELECT session_id, skill_name, COUNT(*) c FROM tool_calls WHERE skill_name IS NOT NULL${aSess} GROUP BY session_id, skill_name`).all()) {
+    const m = skillMix.get(r.session_id) ?? {};
+    m[r.skill_name] = r.c;
+    skillMix.set(r.session_id, m);
+  }
+  const tokens = /* @__PURE__ */ new Map();
+  for (const r of db.prepare(`SELECT session_id, SUM(input_tokens) i, SUM(output_tokens) o,
+              SUM(cache_creation_input_tokens) cw, SUM(cache_read_input_tokens) cr
+       FROM token_usage${wSess} GROUP BY session_id`).all()) {
+    tokens.set(r.session_id, { work: (r.i ?? 0) + (r.o ?? 0) + (r.cw ?? 0), cacheRead: r.cr ?? 0 });
+  }
+  const loc = /* @__PURE__ */ new Map();
+  for (const r of db.prepare(`SELECT session_id, tool_name, input_json FROM tool_calls WHERE tool_name IN ('Edit','Write')${aSess}`).all()) {
+    const d = locDelta(r.tool_name, r.input_json);
+    const acc = loc.get(r.session_id) ?? { added: 0, removed: 0, files: /* @__PURE__ */ new Set() };
+    acc.added += d.added;
+    acc.removed += d.removed;
+    if (d.file)
+      acc.files.add(d.file);
+    loc.set(r.session_id, acc);
+  }
+  const promptText = /* @__PURE__ */ new Map();
+  for (const r of db.prepare(`SELECT session_id, prompt_preview FROM turns WHERE prompt_preview IS NOT NULL${aSess}`).all()) {
+    promptText.set(r.session_id, (promptText.get(r.session_id) ?? "") + " " + r.prompt_preview);
+  }
+  const subagentRole = /* @__PURE__ */ new Map();
+  for (const r of db.prepare(`SELECT s.id id, tc.agent_type role FROM sessions s JOIN tool_calls tc ON tc.spawned_session_id = s.id WHERE s.is_sidechain = 1 AND tc.agent_type IS NOT NULL${incremental ? " AND s.id IN (SELECT id FROM _dirty)" : ""}`).all()) {
+    if (!subagentRole.has(r.id))
+      subagentRole.set(r.id, r.role);
+  }
+  const upsert = db.prepare(`INSERT INTO classifications (scope, target_id, category, complexity_score, complexity_band, signals_json, classifier_version)
+     VALUES ('session', @target_id, @category, @complexity_score, @complexity_band, @signals_json, @classifier_version)
+     ON CONFLICT(scope, target_id) DO UPDATE SET
+       category=excluded.category, complexity_score=excluded.complexity_score,
+       complexity_band=excluded.complexity_band, signals_json=excluded.signals_json,
+       classifier_version=excluded.classifier_version`);
+  const tx = db.transaction(() => {
+    for (const sess of sessions) {
+      const toolCounts = toolMix.get(sess.id) ?? {};
+      const skills = skillMix.get(sess.id) ?? {};
+      const l = loc.get(sess.id) ?? { added: 0, removed: 0, files: /* @__PURE__ */ new Set() };
+      const tok = tokens.get(sess.id) ?? { work: 0, cacheRead: 0 };
+      const filesArr = [...l.files].sort();
+      const subagentCount = (toolCounts["Agent"] ?? 0) + (toolCounts["Task"] ?? 0);
+      const signals = {
+        toolCounts,
+        skills,
+        loc: { added: l.added, removed: l.removed, net: l.added - l.removed, churn: l.added + l.removed, files: l.files.size },
+        turn_count: sess.turn_count,
+        event_count: sess.event_count,
+        work_tokens: tok.work,
+        cache_read_tokens: tok.cacheRead,
+        duration_ms: sess.duration_ms ?? 0,
+        subagent_count: subagentCount,
+        is_sidechain: sess.is_sidechain,
+        _files: filesArr
+      };
+      const catScores = scoreCategories(signals, promptText.get(sess.id) ?? "");
+      let category = "chore";
+      let bestScore = -1;
+      for (const c of CATEGORIES) {
+        if (catScores[c] > bestScore) {
+          bestScore = catScores[c];
+          category = c;
+        }
+      }
+      const role = subagentRole.get(sess.id);
+      if (sess.is_sidechain) {
+        const roleCat = categoryForSubagentRole(role);
+        if (roleCat)
+          category = roleCat;
+      }
+      const cx = complexity(signals);
+      const signalsJson = JSON.stringify({
+        tool_counts: toolCounts,
+        skills,
+        loc: signals.loc,
+        files: filesArr,
+        turn_count: signals.turn_count,
+        event_count: signals.event_count,
+        work_tokens: signals.work_tokens,
+        cache_read_tokens: signals.cache_read_tokens,
+        duration_ms: signals.duration_ms,
+        subagent_count: signals.subagent_count,
+        is_sidechain: signals.is_sidechain,
+        subagent_role: role ?? null,
+        category_scores: catScores,
+        complexity_subscores: cx.subscores,
+        complexity_weights: cx.weights,
+        classifier_version: CLASSIFIER_VERSION
+      });
+      upsert.run({
+        target_id: sess.id,
+        category,
+        complexity_score: cx.score,
+        complexity_band: band(cx.score),
+        signals_json: signalsJson,
+        classifier_version: CLASSIFIER_VERSION
+      });
+    }
+  });
+  tx();
+  if (incremental)
+    db.exec("DROP TABLE IF EXISTS _dirty");
+  return { count: sessions.length, version: CLASSIFIER_VERSION };
+}
+
+// ../ingest/dist/pipeline.js
+import { createHash } from "crypto";
+function newStats() {
+  return { files: 0, skipped: 0, malformed: 0, newEvents: 0 };
+}
+function preview(text) {
+  return text.replace(/\s+/g, " ").trim().slice(0, 140);
+}
+var SKILL_INJECT_PREFIX = "Base directory for this skill:";
+function skillNameKey(name) {
+  const afterSlash = name.split("/").pop() ?? name;
+  const afterColon = afterSlash.split(":").pop() ?? afterSlash;
+  return afterColon.trim();
+}
+function parseSkillInjection(text) {
+  if (!text.startsWith(SKILL_INJECT_PREFIX))
+    return null;
+  const firstNl = text.indexOf("\n");
+  const firstLine = (firstNl >= 0 ? text.slice(0, firstNl) : text).slice(SKILL_INJECT_PREFIX.length).trim();
+  const baseDir = firstLine || null;
+  let body = firstNl >= 0 ? text.slice(firstNl + 1) : "";
+  let args = null;
+  const argIdx = body.lastIndexOf("\nARGUMENTS:");
+  if (argIdx >= 0) {
+    args = body.slice(argIdx + "\nARGUMENTS:".length).trim() || null;
+    body = body.slice(0, argIdx);
+  }
+  return { baseDir, nameKey: baseDir ? skillNameKey(baseDir) : "", body: body.trim(), args };
+}
+function skillSummary(body) {
+  for (const line of body.split("\n")) {
+    const t = line.trim();
+    if (!t)
+      continue;
+    return (t.startsWith("#") ? t.replace(/^#+\s*/, "").trim() : t).slice(0, 200) || null;
+  }
+  return null;
+}
+function skillVersionId(name, body) {
+  return createHash("sha1").update(name).update("\0").update(body).digest("hex").slice(0, 16);
+}
+function pruneExcluded(db, excludedPaths) {
+  if (!excludedPaths.length)
+    return 0;
+  const projects = db.prepare("SELECT id, path FROM projects").all();
+  const projIds = projects.filter((p) => excludedPaths.some((e) => p.path === e || p.path.startsWith(e + "/"))).map((p) => p.id);
+  if (!projIds.length)
+    return 0;
+  db.exec("DROP TABLE IF EXISTS _prune");
+  db.exec("CREATE TEMP TABLE _prune (id TEXT PRIMARY KEY)");
+  const insP = db.prepare("INSERT OR IGNORE INTO _prune (id) VALUES (?)");
+  const seed = db.prepare(`SELECT id FROM sessions WHERE project_id IN (${projIds.map(() => "?").join(",")})`).all(...projIds);
+  db.transaction(() => {
+    for (const s of seed)
+      insP.run(s.id);
+  })();
+  const expand = db.prepare("INSERT OR IGNORE INTO _prune (id) SELECT id FROM sessions WHERE parent_session_id IN (SELECT id FROM _prune)");
+  const cnt = db.prepare("SELECT COUNT(*) n FROM _prune");
+  for (let prev = -1; ; ) {
+    const n = cnt.get().n;
+    if (n === prev)
+      break;
+    prev = n;
+    expand.run();
+  }
+  const total = cnt.get().n;
+  if (!total) {
+    db.exec("DROP TABLE IF EXISTS _prune");
+    return 0;
+  }
+  const files = db.prepare("SELECT DISTINCT source_file f FROM events WHERE session_id IN (SELECT id FROM _prune) AND source_file IS NOT NULL").all().map((r) => r.f);
+  db.pragma("foreign_keys = OFF");
+  db.transaction(() => {
+    for (const t of ["token_usage", "tool_calls", "turns", "events"])
+      db.exec(`DELETE FROM ${t} WHERE session_id IN (SELECT id FROM _prune)`);
+    db.exec("DELETE FROM classifications WHERE scope = 'session' AND target_id IN (SELECT id FROM _prune)");
+    db.exec("DELETE FROM sessions WHERE id IN (SELECT id FROM _prune)");
+    const delState = db.prepare("DELETE FROM ingest_state WHERE file_path = ?");
+    for (const f of files)
+      delState.run(f);
+    db.exec("DELETE FROM projects WHERE id NOT IN (SELECT DISTINCT project_id FROM sessions WHERE project_id IS NOT NULL)");
+  })();
+  db.pragma("foreign_keys = ON");
+  db.exec("DROP TABLE IF EXISTS _prune");
+  return total;
+}
+function durationMs(start, end) {
+  if (!start || !end)
+    return null;
+  const a = Date.parse(start);
+  const b = Date.parse(end);
+  if (Number.isNaN(a) || Number.isNaN(b))
+    return null;
+  return Math.max(0, b - a);
+}
+function buildTurns(sessionId, rows) {
+  rows.sort((x, y) => (x.timestamp ?? "").localeCompare(y.timestamp ?? "") || x.uuid.localeCompare(y.uuid));
+  const turns = [];
+  const eventTurn = /* @__PURE__ */ new Map();
+  let cur = null;
+  let seq = 0;
+  for (const e of rows) {
+    const isPrompt = e.type === "user" && e.is_meta === 0 && !!e.text && e.text.trim().length > 0;
+    if (isPrompt) {
+      cur = {
+        id: `${sessionId}:${seq}`,
+        session_id: sessionId,
+        seq,
+        user_event_uuid: e.uuid,
+        prompt_preview: preview(e.text),
+        model: null,
+        started_at: e.timestamp,
+        ended_at: e.timestamp,
+        duration_ms: null
+      };
+      turns.push(cur);
+      seq++;
+    }
+    if (cur) {
+      eventTurn.set(e.uuid, cur.id);
+      if (e.model)
+        cur.model = e.model;
+      if (e.timestamp && (!cur.ended_at || e.timestamp > cur.ended_at))
+        cur.ended_at = e.timestamp;
+    }
+  }
+  for (const t of turns)
+    t.duration_ms = durationMs(t.started_at, t.ended_at);
+  return { turns, eventTurn };
+}
+function rebuildDerived(db, dirty) {
+  const incremental = dirty != null;
+  const bySession = incremental ? " WHERE session_id IN (SELECT id FROM _dirty)" : "";
+  const byId = incremental ? " WHERE id IN (SELECT id FROM _dirty)" : "";
+  const andId = incremental ? " AND id IN (SELECT id FROM _dirty)" : "";
+  const andSelfId = incremental ? " AND sessions.id IN (SELECT id FROM _dirty)" : "";
+  if (incremental) {
+    db.exec("DROP TABLE IF EXISTS _dirty");
+    db.exec("CREATE TEMP TABLE _dirty (id TEXT PRIMARY KEY)");
+    const ins = db.prepare("INSERT OR IGNORE INTO _dirty (id) VALUES (?)");
+    db.transaction((ids) => {
+      for (const id of ids)
+        ins.run(id);
+    })(dirty);
+    const expand = db.prepare(`
+      INSERT OR IGNORE INTO _dirty (id)
+        SELECT spawned_session_id FROM tool_calls
+          WHERE session_id IN (SELECT id FROM _dirty) AND spawned_session_id IS NOT NULL
+        UNION
+        SELECT session_id FROM tool_calls
+          WHERE spawned_session_id IN (SELECT id FROM _dirty)
+        UNION
+        -- structural (path-based) workflow linkage: a dirty parent pulls in its subagent children,
+        -- and a dirty child pulls in its structural parent, so the fallback link stays correct when
+        -- parent and child transcripts arrive in different runs (ADR-010).
+        SELECT id FROM sessions
+          WHERE spawn_parent_id IN (SELECT id FROM _dirty)
+        UNION
+        SELECT spawn_parent_id FROM sessions
+          WHERE id IN (SELECT id FROM _dirty) AND spawn_parent_id IS NOT NULL
+    `);
+    const count = db.prepare("SELECT COUNT(*) n FROM _dirty");
+    let prev = -1;
+    for (; ; ) {
+      const n = count.get().n;
+      if (n === prev)
+        break;
+      prev = n;
+      expand.run();
+    }
+  }
+  db.exec(`UPDATE events SET turn_id = NULL${bySession}`);
+  db.exec(`UPDATE token_usage SET turn_id = NULL${bySession}`);
+  db.exec(`UPDATE tool_calls SET turn_id = NULL${bySession}`);
+  db.exec(`UPDATE tool_calls SET skill_id = NULL${bySession}`);
+  db.exec(`UPDATE sessions SET parent_turn_id = NULL${byId}`);
+  db.exec(`DELETE FROM turns${bySession}`);
+  const sessionIds = db.prepare(`SELECT id FROM sessions${byId}`).all();
+  const selEvents = db.prepare("SELECT uuid, type, is_sidechain, is_meta, timestamp, model, text FROM events WHERE session_id = ?");
+  const insTurn = db.prepare(`INSERT INTO turns (id, session_id, seq, user_event_uuid, prompt_preview, model, started_at, ended_at, duration_ms)
+     VALUES (@id, @session_id, @seq, @user_event_uuid, @prompt_preview, @model, @started_at, @ended_at, @duration_ms)`);
+  const updEventTurn = db.prepare("UPDATE events SET turn_id = ? WHERE uuid = ?");
+  const tx = db.transaction(() => {
+    for (const { id } of sessionIds) {
+      const rows = selEvents.all(id);
+      const { turns, eventTurn } = buildTurns(id, rows);
+      for (const t of turns)
+        insTurn.run(t);
+      for (const [uuid, turnId] of eventTurn)
+        updEventTurn.run(turnId, uuid);
+    }
+  });
+  tx();
+  db.exec(`UPDATE token_usage SET turn_id = (SELECT turn_id FROM events WHERE events.uuid = token_usage.event_uuid)${bySession}`);
+  db.exec(`UPDATE tool_calls SET turn_id = (SELECT turn_id FROM events WHERE events.uuid = tool_calls.event_uuid)${bySession}`);
+  {
+    const selEventsOrdered = db.prepare("SELECT uuid, type, is_meta, timestamp, text FROM events WHERE session_id = ?");
+    const selSkillCalls = db.prepare("SELECT id, event_uuid, skill_name, input_json FROM tool_calls WHERE session_id = ? AND tool_name = 'Skill'");
+    const upsertSkill = db.prepare(`INSERT INTO skills (id, name, base_dir, body, summary, body_bytes, first_seen, last_seen)
+       VALUES (@id, @name, @base_dir, @body, @summary, @body_bytes, @ts, @ts)
+       ON CONFLICT(id) DO UPDATE SET
+         last_seen  = MAX(last_seen,  excluded.last_seen),
+         first_seen = MIN(first_seen, excluded.first_seen),
+         base_dir   = excluded.base_dir`);
+    const linkCall = db.prepare("UPDATE tool_calls SET skill_id = ? WHERE id = ?");
+    const linkTx = db.transaction(() => {
+      for (const { id: sid } of sessionIds) {
+        const calls = selSkillCalls.all(sid);
+        if (!calls.length)
+          continue;
+        const events = selEventsOrdered.all(sid).sort((x, y) => (x.timestamp ?? "").localeCompare(y.timestamp ?? "") || x.uuid.localeCompare(y.uuid));
+        const callByEvent = /* @__PURE__ */ new Map();
+        for (const c of calls) {
+          if (!c.event_uuid)
+            continue;
+          const arr = callByEvent.get(c.event_uuid) ?? [];
+          arr.push(c);
+          callByEvent.set(c.event_uuid, arr);
+        }
+        const pending = /* @__PURE__ */ new Map();
+        for (const e of events) {
+          const here = callByEvent.get(e.uuid);
+          if (here) {
+            for (const c2 of here) {
+              if (!c2.skill_name)
+                continue;
+              const key = skillNameKey(c2.skill_name);
+              let args = null;
+              try {
+                args = c2.input_json ? JSON.parse(c2.input_json).args ?? null : null;
+                if (typeof args === "string")
+                  args = args.trim() || null;
+                else if (args != null)
+                  args = JSON.stringify(args);
+              } catch {
+              }
+              const arr = pending.get(key) ?? [];
+              arr.push({ id: c2.id, args });
+              pending.set(key, arr);
+            }
+          }
+          if (e.is_meta !== 1 || e.type !== "user" || !e.text)
+            continue;
+          const inj = parseSkillInjection(e.text);
+          if (!inj)
+            continue;
+          const queue = pending.get(inj.nameKey);
+          if (!queue || !queue.length)
+            continue;
+          let idx = inj.args != null ? queue.findIndex((q) => q.args === inj.args) : -1;
+          if (idx < 0)
+            idx = 0;
+          const [match] = queue.splice(idx, 1);
+          const c = calls.find((x) => x.id === match.id);
+          const name = c.skill_name;
+          const vid = skillVersionId(name, inj.body);
+          upsertSkill.run({
+            id: vid,
+            name,
+            base_dir: inj.baseDir,
+            body: inj.body,
+            summary: skillSummary(inj.body),
+            body_bytes: Buffer.byteLength(inj.body, "utf8"),
+            ts: e.timestamp
+          });
+          linkCall.run(vid, match.id);
+        }
+      }
+    });
+    linkTx();
+  }
+  db.exec(`
+    UPDATE sessions SET
+      parent_session_id = (SELECT tc.session_id FROM tool_calls tc WHERE tc.spawned_session_id = sessions.id),
+      parent_turn_id    = (SELECT tc.turn_id    FROM tool_calls tc WHERE tc.spawned_session_id = sessions.id)
+    WHERE EXISTS (SELECT 1 FROM tool_calls tc WHERE tc.spawned_session_id = sessions.id)${andSelfId}
+  `);
+  db.exec(`
+    UPDATE sessions SET
+      parent_session_id = COALESCE(parent_session_id, (SELECT tc.session_id FROM tool_calls tc WHERE tc.workflow_run_id = sessions.workflow_run_id LIMIT 1)),
+      parent_turn_id    = COALESCE(parent_turn_id,    (SELECT tc.turn_id    FROM tool_calls tc WHERE tc.workflow_run_id = sessions.workflow_run_id LIMIT 1))
+    WHERE sessions.workflow_run_id IS NOT NULL
+      AND EXISTS (SELECT 1 FROM tool_calls tc WHERE tc.workflow_run_id = sessions.workflow_run_id)${andSelfId}
+  `);
+  db.exec(`
+    UPDATE sessions SET parent_session_id = spawn_parent_id
+    WHERE parent_session_id IS NULL
+      AND spawn_parent_id IS NOT NULL
+      AND spawn_parent_id IN (SELECT id FROM sessions)${andSelfId}
+  `);
+  db.exec(`
+    UPDATE sessions SET
+      event_count = (SELECT COUNT(*) FROM events e WHERE e.session_id = sessions.id),
+      started_at  = (SELECT MIN(timestamp) FROM events e WHERE e.session_id = sessions.id),
+      ended_at    = (SELECT MAX(timestamp) FROM events e WHERE e.session_id = sessions.id),
+      turn_count  = (SELECT COUNT(*) FROM turns t WHERE t.session_id = sessions.id),
+      is_sidechain = (SELECT CASE WHEN MIN(is_sidechain) = 1 THEN 1 ELSE 0 END FROM events e WHERE e.session_id = sessions.id)${byId}
+  `);
+  db.exec(`
+    UPDATE sessions SET duration_ms =
+      CAST((julianday(ended_at) - julianday(started_at)) * 86400000 AS INTEGER)
+    WHERE started_at IS NOT NULL AND ended_at IS NOT NULL${andId}
+  `);
+  db.exec(`DELETE FROM sessions WHERE event_count = 0${andId}`);
+  db.exec("DELETE FROM classifications WHERE scope = 'session' AND target_id NOT IN (SELECT id FROM sessions)");
+  if (!incremental) {
+    db.exec("DELETE FROM skills WHERE id NOT IN (SELECT skill_id FROM tool_calls WHERE skill_id IS NOT NULL)");
+  }
+  if (incremental) {
+    const expanded = new Set(db.prepare("SELECT id FROM _dirty").all().map((r) => r.id));
+    db.exec("DROP TABLE IF EXISTS _dirty");
+    return expanded;
+  }
+  return null;
+}
+function prepareStatements(db) {
+  return {
+    insAgent: db.prepare("INSERT OR IGNORE INTO agents (id, name, kind) VALUES (?, ?, 'cli')"),
+    insSource: db.prepare(`INSERT INTO sources (id, label, agent_id, config_dir) VALUES (@id, @label, @agent_id, @config_dir)
+       ON CONFLICT(id) DO UPDATE SET label=excluded.label, agent_id=excluded.agent_id, config_dir=excluded.config_dir`),
+    getState: db.prepare("SELECT size, mtime_ms, sha256, events_ingested FROM ingest_state WHERE file_path = ?"),
+    setState: db.prepare(`INSERT INTO ingest_state (file_path, size, mtime_ms, sha256, events_ingested, ingested_at)
+       VALUES (@file_path, @size, @mtime_ms, @sha256, @events_ingested, @ingested_at)
+       ON CONFLICT(file_path) DO UPDATE SET
+         size=excluded.size, mtime_ms=excluded.mtime_ms, sha256=excluded.sha256,
+         events_ingested=excluded.events_ingested, ingested_at=excluded.ingested_at`),
+    insEvent: db.prepare(`INSERT INTO events (uuid, session_id, turn_id, parent_uuid, seq, type, role, timestamp, model, is_sidechain, is_meta, text, raw_json, source_file)
+       VALUES (@uuid, @session_id, @turn_id, @parent_uuid, @seq, @type, @role, @timestamp, @model, @is_sidechain, @is_meta, @text, @raw_json, @source_file)
+       ON CONFLICT(uuid) DO NOTHING`),
+    insTokens: db.prepare(
+      // Bare ON CONFLICT (no target) so the insert is skipped on EITHER the event_uuid PK or the
+      // unique (session_id, message_id) index — the latter collapses a response's repeated
+      // per-content-block usage lines into a single row.
+      `INSERT INTO token_usage (event_uuid, session_id, turn_id, message_id, model, input_tokens, output_tokens, cache_creation_input_tokens, cache_read_input_tokens, service_tier)
+       VALUES (@event_uuid, @session_id, @turn_id, @message_id, @model, @input_tokens, @output_tokens, @cache_creation_input_tokens, @cache_read_input_tokens, @service_tier)
+       ON CONFLICT DO NOTHING`
+    ),
+    insTool: db.prepare(`INSERT INTO tool_calls (id, event_uuid, session_id, turn_id, tool_name, caller, skill_name, skill_id, agent_type, spawned_session_id, workflow_run_id, workflow_name, resolved_model, status, total_duration_ms, total_tokens, total_tool_use_count, input_json, result_summary)
+       VALUES (@id, @event_uuid, @session_id, @turn_id, @tool_name, @caller, @skill_name, @skill_id, @agent_type, @spawned_session_id, @workflow_run_id, @workflow_name, @resolved_model, @status, @total_duration_ms, @total_tokens, @total_tool_use_count, @input_json, @result_summary)
+       ON CONFLICT(id) DO NOTHING`),
+    patchTool: db.prepare(`UPDATE tool_calls SET
+         status = COALESCE(@status, status),
+         agent_type = COALESCE(@agent_type, agent_type),
+         spawned_session_id = COALESCE(@spawned_session_id, spawned_session_id),
+         workflow_run_id = COALESCE(@workflow_run_id, workflow_run_id),
+         workflow_name = COALESCE(@workflow_name, workflow_name),
+         resolved_model = COALESCE(@resolved_model, resolved_model),
+         total_duration_ms = COALESCE(@total_duration_ms, total_duration_ms),
+         total_tokens = COALESCE(@total_tokens, total_tokens),
+         total_tool_use_count = COALESCE(@total_tool_use_count, total_tool_use_count),
+         result_summary = COALESCE(@result_summary, result_summary)
+       WHERE id = @tool_use_id`),
+    upsertProject: db.prepare(`INSERT INTO projects (id, agent_id, path, encoded_dir, first_seen, last_seen)
+       VALUES (@id, @agent_id, @path, @encoded_dir, @now, @now)
+       ON CONFLICT(id) DO UPDATE SET last_seen = @now, encoded_dir = COALESCE(excluded.encoded_dir, encoded_dir)`),
+    insSessionStub: db.prepare("INSERT OR IGNORE INTO sessions (id, agent_id, source_id) VALUES (?, ?, ?)"),
+    upsertSession: db.prepare(`INSERT INTO sessions (id, agent_id, source_id, project_id, slug, ai_title, cli_version, entrypoint, git_branch, spawn_parent_id, workflow_run_id)
+       VALUES (@id, @agent_id, @source_id, @project_id, @slug, @ai_title, @cli_version, @entrypoint, @git_branch, @spawn_parent_id, @workflow_run_id)
+       ON CONFLICT(id) DO UPDATE SET
+         source_id = COALESCE(excluded.source_id, source_id),
+         project_id = COALESCE(excluded.project_id, project_id),
+         slug = COALESCE(excluded.slug, slug),
+         ai_title = COALESCE(excluded.ai_title, ai_title),
+         cli_version = COALESCE(excluded.cli_version, cli_version),
+         entrypoint = COALESCE(excluded.entrypoint, entrypoint),
+         git_branch = COALESCE(excluded.git_branch, git_branch),
+         spawn_parent_id = COALESCE(excluded.spawn_parent_id, spawn_parent_id),
+         workflow_run_id = COALESCE(excluded.workflow_run_id, workflow_run_id)`)
+  };
+}
+function ingestFile(db, stmts, adapter, file, lines, meta, now, stats) {
+  const sessionMeta = {};
+  let eventsInFile = 0;
+  const tx = db.transaction(() => {
+    stmts.insSessionStub.run(file.sessionId, adapter.agentId, file.sourceId);
+    let seq = 0;
+    for (const line of lines) {
+      if (!line.trim())
+        continue;
+      let raw;
+      try {
+        raw = JSON.parse(line);
+      } catch {
+        stats.malformed++;
+        continue;
+      }
+      const parsed = adapter.parseLine(raw, file, seq++);
+      if (parsed.meta)
+        Object.assign(sessionMeta, parsed.meta);
+      if (parsed.event) {
+        const info = stmts.insEvent.run({ ...parsed.event, raw_json: packRaw(parsed.event.raw_json) });
+        if (info.changes > 0) {
+          stats.newEvents++;
+          eventsInFile++;
+        }
+      }
+      if (parsed.tokenUsage)
+        stmts.insTokens.run(parsed.tokenUsage);
+      if (parsed.toolCalls)
+        for (const tc of parsed.toolCalls)
+          stmts.insTool.run(tc);
+      if (parsed.toolResults)
+        for (const tr of parsed.toolResults)
+          stmts.patchTool.run({
+            tool_use_id: tr.tool_use_id,
+            status: tr.status ?? null,
+            agent_type: tr.agent_type ?? null,
+            spawned_session_id: tr.spawned_session_id ?? null,
+            workflow_run_id: tr.workflow_run_id ?? null,
+            workflow_name: tr.workflow_name ?? null,
+            resolved_model: tr.resolved_model ?? null,
+            total_duration_ms: tr.total_duration_ms ?? null,
+            total_tokens: tr.total_tokens ?? null,
+            total_tool_use_count: tr.total_tool_use_count ?? null,
+            result_summary: tr.result_summary ?? null
+          });
+    }
+    let projectId = null;
+    if (sessionMeta.cwd) {
+      projectId = createHash("sha1").update(`${adapter.agentId}\0${sessionMeta.cwd}`).digest("hex").slice(0, 16);
+      stmts.upsertProject.run({
+        id: projectId,
+        agent_id: adapter.agentId,
+        path: sessionMeta.cwd,
+        encoded_dir: file.encodedDir || null,
+        now
+      });
+    }
+    stmts.upsertSession.run({
+      id: file.sessionId,
+      agent_id: adapter.agentId,
+      source_id: file.sourceId,
+      project_id: projectId,
+      slug: sessionMeta.slug ?? null,
+      ai_title: sessionMeta.ai_title ?? null,
+      cli_version: sessionMeta.cli_version ?? null,
+      entrypoint: sessionMeta.entrypoint ?? null,
+      git_branch: sessionMeta.git_branch ?? null,
+      spawn_parent_id: file.parentSessionId ?? null,
+      workflow_run_id: file.workflowRunId ?? null
+    });
+    stmts.setState.run({
+      file_path: file.path,
+      size: meta.size,
+      mtime_ms: Math.trunc(meta.mtimeMs),
+      sha256: meta.hash,
+      events_ingested: eventsInFile,
+      ingested_at: now
+    });
+  });
+  tx();
+}
+
+// ../ingest/dist/redact.js
+import { createHash as createHash2, randomBytes } from "crypto";
+function parseExcludes(csv) {
+  return (csv ?? "").split(",").map((s) => s.trim()).filter(Boolean).map(encodeProjectPath);
+}
+function isExcludedArchivePath(filePath, excluded) {
+  return excluded.some((e) => filePath.includes(`/projects/${e}/`));
+}
+
+// ../ingest/dist/fileread.js
+import { createHash as createHash3 } from "crypto";
+import { openSync as openSync2, readSync as readSync2, closeSync as closeSync2 } from "fs";
+import { StringDecoder } from "string_decoder";
+var STREAM_THRESHOLD = 8 * 1024 * 1024;
+var CHUNK2 = 64 * 1024;
+function sha256(buf) {
+  return createHash3("sha256").update(buf).digest("hex");
+}
+function sha256File(path) {
+  const fd = openSync2(path, "r");
+  const h = createHash3("sha256");
+  const buf = Buffer.allocUnsafe(CHUNK2);
+  try {
+    let n;
+    while ((n = readSync2(fd, buf, 0, CHUNK2, null)) > 0)
+      h.update(buf.subarray(0, n));
+  } finally {
+    closeSync2(fd);
+  }
+  return h.digest("hex");
+}
+function* streamLines(path) {
+  const fd = openSync2(path, "r");
+  const decoder = new StringDecoder("utf8");
+  const buf = Buffer.allocUnsafe(CHUNK2);
+  let leftover = "";
+  try {
+    let n;
+    while ((n = readSync2(fd, buf, 0, CHUNK2, null)) > 0) {
+      leftover += decoder.write(buf.subarray(0, n));
+      let idx;
+      while ((idx = leftover.indexOf("\n")) !== -1) {
+        yield leftover.slice(0, idx);
+        leftover = leftover.slice(idx + 1);
+      }
+    }
+    leftover += decoder.end();
+    if (leftover.length > 0)
+      yield leftover;
+  } finally {
+    closeSync2(fd);
+  }
+}
+
+// ../ingest/dist/run.js
+function parseIngestArgs(argv) {
+  const a = { full: false, db: "", archive: "" };
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i] === "--full")
+      a.full = true;
+    else if (argv[i] === "--db")
+      a.db = argv[++i] ?? "";
+    else if (argv[i] === "--archive")
+      a.archive = argv[++i] ?? "";
+  }
+  return a;
+}
+function runIngest(argv = process.argv.slice(2)) {
+  const args = parseIngestArgs(argv);
+  const dataDir = resolveDataDir(findRepoRoot());
+  const archiveRoot = args.archive || process.env.AGENT_LENS_ARCHIVE || join5(dataDir, "archive");
+  const dbPath = args.db || process.env.AGENT_LENS_DB || join5(dataDir, "agent-lens.db");
+  if (!existsSync4(archiveRoot)) {
+    console.error(`agent-lens-ingest: archive not found: ${archiveRoot} (run 'agent-lens collect' first)`);
+    process.exit(1);
+  }
+  mkdirSync4(dirname4(dbPath), { recursive: true });
+  const db = args.full ? openRaw(dbPath) : openDb(dbPath);
+  if (args.full)
+    resetSchema(db);
+  const adapterList = [new ClaudeCodeAdapter()];
+  const adapterById = new Map(adapterList.map((a) => [a.agentId, a]));
+  const sources = loadSources();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const excludePaths = loadExcludes();
+  const excludedDirs = parseExcludes(excludePaths.join(","));
+  const pruned = pruneExcluded(db, excludePaths);
+  const stmts = prepareStatements(db);
+  const stats = newStats();
+  const dirty = /* @__PURE__ */ new Set();
+  for (const source of sources) {
+    const adapter = adapterById.get(source.agent);
+    if (!adapter) {
+      console.warn(`agent-lens-ingest: no adapter for agent '${source.agent}' (source '${source.label}') \u2014 skipping`);
+      continue;
+    }
+    stmts.insAgent.run(adapter.agentId, adapter.agentName);
+    stmts.insSource.run({ id: source.label, label: source.label, agent_id: adapter.agentId, config_dir: source.configDir });
+    let files = adapter.discover(join5(archiveRoot, source.label), source.label);
+    if (excludedDirs.length)
+      files = files.filter((f) => !isExcludedArchivePath(f.path, excludedDirs));
+    files.sort((a, b) => Number(a.isVersion) - Number(b.isVersion));
+    for (const file of files) {
+      stats.files++;
+      const st = statSync2(file.path);
+      const mtimeMs = Math.trunc(st.mtimeMs);
+      const prev = args.full ? void 0 : stmts.getState.get(file.path);
+      if (prev && prev.size === st.size && prev.mtime_ms === mtimeMs) {
+        stats.skipped++;
+        continue;
+      }
+      const small = st.size <= STREAM_THRESHOLD;
+      const buf = small ? readFileSync4(file.path) : null;
+      const hash = small ? sha256(buf) : sha256File(file.path);
+      if (prev && prev.sha256 === hash) {
+        stmts.setState.run({
+          file_path: file.path,
+          size: st.size,
+          mtime_ms: mtimeMs,
+          sha256: hash,
+          events_ingested: prev.events_ingested,
+          ingested_at: now
+        });
+        stats.skipped++;
+        continue;
+      }
+      const lines = small ? buf.toString("utf8").split("\n") : streamLines(file.path);
+      ingestFile(db, stmts, adapter, file, lines, { size: st.size, mtimeMs, hash }, now, stats);
+      dirty.add(file.sessionId);
+    }
+  }
+  const expanded = rebuildDerived(db, args.full ? null : dirty);
+  const classified = classify(db, args.full ? null : expanded);
+  const count = (sql) => db.prepare(sql).get().n;
+  const sessions = count("SELECT COUNT(*) n FROM sessions");
+  const turns = count("SELECT COUNT(*) n FROM turns");
+  const events = count("SELECT COUNT(*) n FROM events");
+  const tools = count("SELECT COUNT(*) n FROM tool_calls");
+  const usageRows = db.prepare("SELECT model, input_tokens, output_tokens, cache_creation_input_tokens, cache_read_input_tokens FROM token_usage").all();
+  let cost = 0;
+  let totalTokens = 0;
+  for (const u of usageRows) {
+    cost += costForUsage(u.model, u);
+    totalTokens += u.input_tokens + u.output_tokens + u.cache_creation_input_tokens + u.cache_read_input_tokens;
+  }
+  db.close();
+  console.log(`agent-lens-ingest: files=${stats.files} skipped=${stats.skipped} new_events=${stats.newEvents} malformed=${stats.malformed}${pruned ? ` excluded_pruned=${pruned}` : ""}
+  sessions=${sessions} turns=${turns} events=${events} tool_calls=${tools} classified=${classified.count}
+  tokens=${totalTokens.toLocaleString()} est_cost=$${cost.toFixed(2)} db=${dbPath}`);
+}
+function runMetrics(argv = process.argv.slice(2)) {
+  let dbArg = "";
+  for (let i = 0; i < argv.length; i++)
+    if (argv[i] === "--db")
+      dbArg = argv[++i] ?? "";
+  const dataDir = resolveDataDir(findRepoRoot());
+  const dbPath = dbArg || process.env.AGENT_LENS_DB || join5(dataDir, "agent-lens.db");
+  if (!existsSync4(dbPath)) {
+    console.error(`agent-lens-metrics: db not found: ${dbPath} (run ingest first)`);
+    process.exit(1);
+  }
+  const db = openDb(dbPath);
+  const r = classify(db);
+  db.close();
+  console.log(`agent-lens-metrics: classified=${r.count} classifier_version=${CLASSIFIER_VERSION} db=${dbPath}`);
+}
+
+// ../server/dist/run.js
+import { existsSync as existsSync7 } from "fs";
+import { dirname as dirname5, join as join7 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+
+// ../server/dist/db.js
+import Database2 from "better-sqlite3";
+function openReadonly(file) {
+  const db = new Database2(file, { readonly: true, fileMustExist: true });
+  db.pragma("query_only = ON");
+  return db;
+}
+function lastIngested(db) {
+  const row = db.prepare("SELECT MAX(ingested_at) AS last FROM ingest_state").get();
+  return row?.last ?? null;
+}
+function extractParts(rawJson) {
+  let text = "";
+  let thinking = "";
+  try {
+    const content = JSON.parse(unpackRaw(rawJson))?.message?.content;
+    if (typeof content === "string")
+      text = content;
+    else if (Array.isArray(content)) {
+      for (const b of content) {
+        if (b?.type === "text" && typeof b.text === "string")
+          text += (text ? "\n" : "") + b.text;
+        else if (b?.type === "thinking" && typeof b.thinking === "string")
+          thinking += (thinking ? "\n" : "") + b.thinking;
+      }
+    }
+  } catch {
+  }
+  return { text: text || null, thinking: thinking || null };
+}
+function listSources(db) {
+  return db.prepare(
+    // Count MAIN sessions only (is_sidechain = 0): the dropdown filters the session list, which
+    // defaults to main-only, so a source's count must match what you'd see — not be inflated by the
+    // many subagent sidechains each task spawns.
+    `SELECT s.id, s.label, s.agent_id, s.config_dir,
+              (SELECT COUNT(*) FROM sessions x WHERE x.source_id = s.id AND x.is_sidechain = 0) AS session_count
+       FROM sources s ORDER BY s.label`
+  ).all();
+}
+function listProjects(db) {
+  return db.prepare(`SELECT p.id, p.path,
+              (SELECT COUNT(*) FROM sessions x WHERE x.project_id = p.id AND x.is_sidechain = 0) AS session_count
+       FROM projects p ORDER BY session_count DESC, p.path`).all();
+}
+function listModels(db) {
+  return db.prepare(`SELECT DISTINCT model FROM token_usage WHERE model IS NOT NULL ORDER BY model`).all().map((r) => r.model);
+}
+function toFtsQuery(raw) {
+  return raw.trim().split(/\s+/).filter(Boolean).map((t) => `"${t.replace(/"/g, '""')}"`).join(" ");
+}
+function listSessions(db, f) {
+  const where = [];
+  const params = [];
+  if (f.source)
+    where.push("s.source_id = ?"), params.push(f.source);
+  if (f.project)
+    where.push("s.project_id = ?"), params.push(f.project);
+  if (f.from)
+    where.push("s.started_at >= ?"), params.push(f.from);
+  if (f.to)
+    where.push("s.started_at <= ?"), params.push(f.to);
+  if (f.kind === "main")
+    where.push("s.is_sidechain = 0");
+  if (f.kind === "subagent")
+    where.push("s.is_sidechain = 1");
+  if (f.model) {
+    where.push("EXISTS (SELECT 1 FROM token_usage t WHERE t.session_id = s.id AND t.model = ?)");
+    params.push(f.model);
+  }
+  if (f.q && f.q.trim()) {
+    const like = `%${f.q.trim()}%`;
+    where.push(`(s.id IN (SELECT DISTINCT e.session_id FROM events e JOIN events_fts f ON f.rowid = e.rowid WHERE events_fts MATCH ?)
+        OR s.slug LIKE ? OR s.ai_title LIKE ?
+        OR s.project_id IN (SELECT id FROM projects WHERE path LIKE ?))`);
+    params.push(toFtsQuery(f.q), like, like, like);
+  }
+  const whereSql = where.length ? `WHERE ${where.join(" AND ")}` : "";
+  const total = db.prepare(`SELECT COUNT(*) n FROM sessions s ${whereSql}`).get(...params).n;
+  const rows = db.prepare(`SELECT s.id, s.ai_title, s.slug, s.source_id, s.is_sidechain, s.started_at, s.ended_at,
+              s.duration_ms, s.event_count, s.turn_count, p.path AS project_path,
+              (SELECT GROUP_CONCAT(DISTINCT model) FROM token_usage t WHERE t.session_id = s.id) AS models
+       FROM sessions s LEFT JOIN projects p ON p.id = s.project_id
+       ${whereSql}
+       ORDER BY s.started_at DESC
+       LIMIT ? OFFSET ?`).all(...params, f.limit, f.offset);
+  const ids = rows.map((r) => r.id);
+  const costBySession = /* @__PURE__ */ new Map();
+  if (ids.length) {
+    const ph = ids.map(() => "?").join(",");
+    const usage = db.prepare(`SELECT session_id, model,
+                SUM(input_tokens) i, SUM(output_tokens) o,
+                SUM(cache_creation_input_tokens) cw, SUM(cache_read_input_tokens) cr
+         FROM token_usage WHERE session_id IN (${ph}) GROUP BY session_id, model`).all(...ids);
+    for (const u of usage) {
+      const acc = costBySession.get(u.session_id) ?? { tokens: 0, cost: 0, split: { input: 0, output: 0, cache_creation: 0, cache_read: 0 } };
+      acc.tokens += u.i + u.o + u.cw + u.cr;
+      acc.split.input += u.i;
+      acc.split.output += u.o;
+      acc.split.cache_creation += u.cw;
+      acc.split.cache_read += u.cr;
+      acc.cost += costForUsage(u.model, {
+        input_tokens: u.i,
+        output_tokens: u.o,
+        cache_creation_input_tokens: u.cw,
+        cache_read_input_tokens: u.cr
+      });
+      costBySession.set(u.session_id, acc);
+    }
+  }
+  for (const r of rows) {
+    const c = costBySession.get(r.id);
+    r.tokens = c?.tokens ?? 0;
+    r.token_split = c?.split ?? { input: 0, output: 0, cache_creation: 0, cache_read: 0 };
+    r.cost = c ? Number(c.cost.toFixed(4)) : 0;
+    r.title = r.ai_title || r.slug || null;
+  }
+  return { total, sessions: rows };
+}
+function getSession(db, id) {
+  const session = db.prepare(`SELECT s.*, p.path AS project_path FROM sessions s
+       LEFT JOIN projects p ON p.id = s.project_id WHERE s.id = ?`).get(id);
+  if (!session)
+    return null;
+  const turns = db.prepare("SELECT * FROM turns WHERE session_id = ? ORDER BY seq").all(id);
+  const eventRows = db.prepare(`SELECT uuid, type, role, timestamp, model, is_sidechain, turn_id, raw_json
+       FROM events WHERE session_id = ? ORDER BY timestamp, seq`).all(id);
+  const toolRows = db.prepare(`SELECT id, event_uuid, tool_name, skill_name, skill_id, agent_type, spawned_session_id,
+              workflow_run_id, workflow_name, status,
+              total_duration_ms, total_tokens, input_json, result_summary,
+              (SELECT COUNT(*) FROM sessions s WHERE s.workflow_run_id = tool_calls.workflow_run_id) AS workflow_agent_count
+       FROM tool_calls WHERE session_id = ?`).all(id);
+  const toolsByEvent = /* @__PURE__ */ new Map();
+  for (const t of toolRows) {
+    if (!t.event_uuid)
+      continue;
+    (toolsByEvent.get(t.event_uuid) ?? toolsByEvent.set(t.event_uuid, []).get(t.event_uuid)).push(t);
+  }
+  const events = eventRows.map((e) => {
+    const { text, thinking } = extractParts(e.raw_json);
+    return {
+      uuid: e.uuid,
+      type: e.type,
+      role: e.role,
+      timestamp: e.timestamp,
+      model: e.model,
+      is_sidechain: e.is_sidechain,
+      turn_id: e.turn_id,
+      text,
+      thinking,
+      toolCalls: toolsByEvent.get(e.uuid) ?? []
+    };
+  });
+  const usage = db.prepare(`SELECT model, SUM(input_tokens) i, SUM(output_tokens) o,
+              SUM(cache_creation_input_tokens) cw, SUM(cache_read_input_tokens) cr
+       FROM token_usage WHERE session_id = ? GROUP BY model`).all(id);
+  const split = { input: 0, output: 0, cache_creation: 0, cache_read: 0 };
+  let cost = 0;
+  for (const u of usage) {
+    split.input += u.i;
+    split.output += u.o;
+    split.cache_creation += u.cw;
+    split.cache_read += u.cr;
+    cost += costForUsage(u.model, {
+      input_tokens: u.i,
+      output_tokens: u.o,
+      cache_creation_input_tokens: u.cw,
+      cache_read_input_tokens: u.cr
+    });
+  }
+  session.tokens = split.input + split.output + split.cache_creation + split.cache_read;
+  session.token_split = split;
+  session.cost = Number(cost.toFixed(4));
+  session.title = session.ai_title || session.slug || null;
+  const cls = db.prepare(`SELECT category, complexity_score, complexity_band, signals_json, classifier_version
+       FROM classifications WHERE scope = 'session' AND target_id = ?`).get(id);
+  let classification = null;
+  if (cls) {
+    let signals = null;
+    try {
+      signals = cls.signals_json ? JSON.parse(cls.signals_json) : null;
+    } catch {
+    }
+    classification = {
+      category: cls.category,
+      complexity_score: cls.complexity_score,
+      complexity_band: cls.complexity_band,
+      classifier_version: cls.classifier_version,
+      signals
+    };
+  }
+  let parent = null;
+  if (session.parent_session_id) {
+    const p = db.prepare(`SELECT ps.id, ps.ai_title, ps.slug, t.seq AS turn_seq
+         FROM sessions ps LEFT JOIN turns t ON t.id = ?
+         WHERE ps.id = ?`).get(session.parent_turn_id, session.parent_session_id);
+    if (p)
+      parent = { id: p.id, title: p.ai_title || p.slug || null, turn_seq: p.turn_seq ?? null };
+  }
+  const children = db.prepare(`SELECT s.id, s.ai_title, s.slug, s.turn_count, s.started_at, s.workflow_run_id,
+              (SELECT GROUP_CONCAT(DISTINCT model) FROM token_usage t WHERE t.session_id = s.id) AS models
+       FROM sessions s WHERE s.parent_session_id = ? ORDER BY s.started_at`).all(id);
+  for (const ch of children) {
+    ch.title = ch.ai_title || ch.slug || null;
+    const u = db.prepare(`SELECT model, SUM(input_tokens) i, SUM(output_tokens) o,
+                SUM(cache_creation_input_tokens) cw, SUM(cache_read_input_tokens) cr
+         FROM token_usage WHERE session_id = ? GROUP BY model`).all(ch.id);
+    ch.tokens = u.reduce((a, r) => a + r.i + r.o + r.cw + r.cr, 0);
+    ch.cost = Number(u.reduce((a, r) => a + costForUsage(r.model, { input_tokens: r.i, output_tokens: r.o, cache_creation_input_tokens: r.cw, cache_read_input_tokens: r.cr }), 0).toFixed(4));
+  }
+  const workflow_runs = db.prepare(`SELECT tc.workflow_run_id AS run_id, tc.workflow_name AS name, t.seq AS turn_seq,
+              (SELECT COUNT(*) FROM sessions s WHERE s.workflow_run_id = tc.workflow_run_id) AS agent_count
+       FROM tool_calls tc LEFT JOIN turns t ON t.id = tc.turn_id
+       WHERE tc.session_id = ? AND tc.workflow_run_id IS NOT NULL
+       ORDER BY t.seq`).all(id);
+  return { session, turns, events, classification, parent, children, workflow_runs };
+}
+function xmlTag(text, tag) {
+  return text.match(new RegExp(`<${tag}>([\\s\\S]*?)</${tag}>`))?.[1]?.trim() ?? null;
+}
+function getWorkflow(db, runId) {
+  const wf = db.prepare(`SELECT tc.id AS tool_use_id, tc.workflow_run_id AS run_id, tc.workflow_name AS name, tc.status, tc.result_summary,
+              tc.session_id AS parent_session_id, t.seq AS turn_seq,
+              ps.ai_title AS parent_ai_title, ps.slug AS parent_slug
+       FROM tool_calls tc
+       LEFT JOIN turns t ON t.id = tc.turn_id
+       LEFT JOIN sessions ps ON ps.id = tc.session_id
+       WHERE tc.workflow_run_id = ? AND tc.tool_name = 'Workflow'
+       ORDER BY t.seq
+       LIMIT 1`).get(runId);
+  if (!wf)
+    return null;
+  const agents = db.prepare(`SELECT s.id, s.ai_title, s.slug, s.turn_count, s.started_at, s.ended_at, s.duration_ms,
+              (SELECT GROUP_CONCAT(DISTINCT model) FROM token_usage t WHERE t.session_id = s.id) AS models
+       FROM sessions s WHERE s.workflow_run_id = ? ORDER BY s.started_at`).all(runId);
+  let total_tokens = 0;
+  let total_cost = 0;
+  let started_at = null;
+  let ended_at = null;
+  for (const a of agents) {
+    a.title = a.ai_title || a.slug || null;
+    const u = db.prepare(`SELECT model, SUM(input_tokens) i, SUM(output_tokens) o,
+                SUM(cache_creation_input_tokens) cw, SUM(cache_read_input_tokens) cr
+         FROM token_usage WHERE session_id = ? GROUP BY model`).all(a.id);
+    a.tokens = u.reduce((acc, r) => acc + r.i + r.o + r.cw + r.cr, 0);
+    a.cost = Number(u.reduce((acc, r) => acc + costForUsage(r.model, { input_tokens: r.i, output_tokens: r.o, cache_creation_input_tokens: r.cw, cache_read_input_tokens: r.cr }), 0).toFixed(4));
+    total_tokens += a.tokens;
+    total_cost += a.cost;
+    if (a.started_at && (!started_at || a.started_at < started_at))
+      started_at = a.started_at;
+    if (a.ended_at && (!ended_at || a.ended_at > ended_at))
+      ended_at = a.ended_at;
+  }
+  const duration_ms = started_at && ended_at ? new Date(ended_at).getTime() - new Date(started_at).getTime() : null;
+  let completion = null;
+  if (wf.tool_use_id && wf.parent_session_id) {
+    const ev = db.prepare(`SELECT raw_json FROM events
+         WHERE session_id = ? AND text LIKE '%<task-notification>%' AND text LIKE ?
+         ORDER BY timestamp DESC LIMIT 1`).get(wf.parent_session_id, `%${wf.tool_use_id}%`);
+    if (ev) {
+      const { text } = extractParts(ev.raw_json);
+      const t = text ?? "";
+      completion = { status: xmlTag(t, "status"), summary: xmlTag(t, "summary"), result: xmlTag(t, "result"), failures: xmlTag(t, "failures") };
+    }
+  }
+  return {
+    run_id: wf.run_id,
+    name: wf.name ?? null,
+    status: wf.status ?? null,
+    result_summary: wf.result_summary ?? null,
+    completion,
+    parent: { id: wf.parent_session_id, title: wf.parent_ai_title || wf.parent_slug || null, turn_seq: wf.turn_seq ?? null },
+    agents,
+    stats: { agent_count: agents.length, total_tokens, total_cost: Number(total_cost.toFixed(4)), started_at, ended_at, duration_ms }
+  };
+}
+function listSkills(db, f = {}) {
+  const where = ["tc.tool_name = 'Skill'", "tc.skill_name IS NOT NULL"];
+  const params = [];
+  if (f.q && f.q.trim())
+    where.push("tc.skill_name LIKE ?"), params.push(`%${f.q.trim()}%`);
+  if (f.source)
+    where.push("s.source_id = ?"), params.push(f.source);
+  if (f.project)
+    where.push("s.project_id = ?"), params.push(f.project);
+  const rows = db.prepare(`SELECT tc.skill_name AS name,
+              COUNT(*) AS call_count,
+              COUNT(DISTINCT tc.skill_id) AS version_count,
+              MAX(e.timestamp) AS last_fired,
+              GROUP_CONCAT(DISTINCT s.source_id) AS sources
+       FROM tool_calls tc
+       JOIN sessions s ON s.id = tc.session_id
+       LEFT JOIN events e ON e.uuid = tc.event_uuid
+       WHERE ${where.join(" AND ")}
+       GROUP BY tc.skill_name
+       ORDER BY call_count DESC, name`).all(...params);
+  for (const r of rows)
+    r.sources = r.sources ? String(r.sources).split(",").filter(Boolean) : [];
+  return rows;
+}
+function getSkill(db, name) {
+  const versions = db.prepare(`SELECT sk.id, sk.base_dir, sk.summary, sk.body, sk.body_bytes, sk.first_seen, sk.last_seen,
+              (SELECT COUNT(*) FROM tool_calls tc WHERE tc.skill_id = sk.id) AS call_count
+       FROM skills sk WHERE sk.name = ? ORDER BY sk.last_seen DESC, sk.id`).all(name);
+  const sessions = db.prepare(`SELECT s.id, s.ai_title, s.slug, s.source_id, s.started_at, p.path AS project_path,
+              tc.skill_id AS version_id, MIN(e.timestamp) AS fired_at, COUNT(*) AS fire_count
+       FROM tool_calls tc
+       JOIN sessions s ON s.id = tc.session_id
+       LEFT JOIN projects p ON p.id = s.project_id
+       LEFT JOIN events e ON e.uuid = tc.event_uuid
+       WHERE tc.tool_name = 'Skill' AND tc.skill_name = ?
+       GROUP BY s.id, tc.skill_id
+       ORDER BY fired_at DESC`).all(name);
+  if (!versions.length && !sessions.length)
+    return null;
+  for (const s of sessions)
+    s.title = s.ai_title || s.slug || null;
+  const call_count = sessions.reduce((a, s) => a + s.fire_count, 0);
+  return { name, versions, sessions, call_count };
+}
+
+// ../server/dist/app.js
+import { existsSync as existsSync6 } from "fs";
+import Fastify from "fastify";
+import fastifyStatic from "@fastify/static";
+
+// ../server/dist/dashboard.js
+function sessionWhere(f) {
+  const where = [];
+  const params = [];
+  if (f.source)
+    where.push("s.source_id = ?"), params.push(f.source);
+  if (f.from)
+    where.push("s.started_at >= ?"), params.push(f.from);
+  if (f.to)
+    where.push("s.started_at <= ?"), params.push(f.to);
+  return { sql: where.length ? `WHERE ${where.join(" AND ")}` : "", params };
+}
+var zeroSplit = () => ({ input: 0, output: 0, cache_creation: 0, cache_read: 0 });
+function addUsage(acc, r) {
+  acc.input += r.i ?? 0;
+  acc.output += r.o ?? 0;
+  acc.cache_creation += r.cw ?? 0;
+  acc.cache_read += r.cr ?? 0;
+}
+function pct(sorted, p) {
+  if (sorted.length === 0)
+    return 0;
+  const rank = Math.ceil(p / 100 * sorted.length) - 1;
+  return sorted[Math.min(Math.max(rank, 0), sorted.length - 1)];
+}
+function dashboardOverview(db, f) {
+  const w = sessionWhere(f);
+  const counts = db.prepare(`SELECT
+         COUNT(*) sessions,
+         SUM(CASE WHEN is_sidechain=0 THEN 1 ELSE 0 END) main,
+         SUM(CASE WHEN is_sidechain=1 THEN 1 ELSE 0 END) subagent,
+         SUM(turn_count) turns,
+         COUNT(DISTINCT project_id) projects
+       FROM sessions s ${w.sql}`).get(...w.params);
+  const toolCount = db.prepare(`SELECT COUNT(*) n FROM tool_calls tc JOIN sessions s ON s.id = tc.session_id ${w.sql}`).get(...w.params).n;
+  const usage = db.prepare(`SELECT t.model model, SUM(t.input_tokens) i, SUM(t.output_tokens) o,
+              SUM(t.cache_creation_input_tokens) cw, SUM(t.cache_read_input_tokens) cr
+       FROM token_usage t JOIN sessions s ON s.id = t.session_id ${w.sql}
+       GROUP BY t.model`).all(...w.params);
+  const tokens = zeroSplit();
+  let cost = 0;
+  const unpriced = [];
+  for (const u of usage) {
+    addUsage(tokens, u);
+    cost += costForUsage(u.model, { input_tokens: u.i, output_tokens: u.o, cache_creation_input_tokens: u.cw, cache_read_input_tokens: u.cr });
+    if (u.model && !rateForModel(u.model) && (u.i || u.o || u.cw || u.cr))
+      unpriced.push(u.model);
+  }
+  const totalTokens = tokens.input + tokens.output + tokens.cache_creation + tokens.cache_read;
+  const durs = db.prepare(`SELECT tn.duration_ms d FROM turns tn JOIN sessions s ON s.id = tn.session_id
+         ${w.sql ? w.sql + " AND" : "WHERE"} tn.duration_ms IS NOT NULL ORDER BY tn.duration_ms`).all(...w.params).map((r) => r.d);
+  return {
+    range: { from: f.from ?? null, to: f.to ?? null, source: f.source ?? null },
+    sessions: counts.sessions ?? 0,
+    sessions_main: counts.main ?? 0,
+    sessions_subagent: counts.subagent ?? 0,
+    turns: counts.turns ?? 0,
+    projects: counts.projects ?? 0,
+    tool_calls: toolCount ?? 0,
+    tokens,
+    // {input, output, cache_creation, cache_read}
+    total_tokens: totalTokens,
+    cache_read_ratio: totalTokens ? tokens.cache_read / totalTokens : 0,
+    cost: Number(cost.toFixed(4)),
+    unpriced_models: [...new Set(unpriced)].sort(),
+    turn_duration_ms: { p50: pct(durs, 50), p95: pct(durs, 95), count: durs.length }
+  };
+}
+function chooseBucket(db, f) {
+  const w = sessionWhere(f);
+  const r = db.prepare(`SELECT MIN(started_at) mn, MAX(started_at) mx FROM sessions s ${w.sql}`).get(...w.params);
+  if (!r?.mn || !r?.mx)
+    return "day";
+  const spanDays = (Date.parse(r.mx) - Date.parse(r.mn)) / 864e5;
+  if (spanDays <= 92)
+    return "day";
+  if (spanDays <= 730)
+    return "week";
+  return "month";
+}
+var BUCKET_EXPR = {
+  day: "strftime('%Y-%m-%d', s.started_at)",
+  week: "strftime('%Y-W%W', s.started_at)",
+  month: "strftime('%Y-%m', s.started_at)"
+};
+function dashboardTimeseries(db, f, bucketParam) {
+  const bucket = bucketParam === "day" || bucketParam === "week" || bucketParam === "month" ? bucketParam : chooseBucket(db, f);
+  const w = sessionWhere(f);
+  const expr = BUCKET_EXPR[bucket];
+  const byBucket = /* @__PURE__ */ new Map();
+  const get = (b) => {
+    let r = byBucket.get(b);
+    if (!r) {
+      r = { bucket: b, ...zeroSplit(), cost: 0, sessions: 0, turns: 0 };
+      byBucket.set(b, r);
+    }
+    return r;
+  };
+  for (const u of db.prepare(`SELECT ${expr} b, t.model model, SUM(t.input_tokens) i, SUM(t.output_tokens) o,
+              SUM(t.cache_creation_input_tokens) cw, SUM(t.cache_read_input_tokens) cr
+       FROM token_usage t JOIN sessions s ON s.id = t.session_id
+       ${w.sql} GROUP BY b, t.model`).all(...w.params)) {
+    if (!u.b)
+      continue;
+    const r = get(u.b);
+    addUsage(r, u);
+    r.cost += costForUsage(u.model, { input_tokens: u.i, output_tokens: u.o, cache_creation_input_tokens: u.cw, cache_read_input_tokens: u.cr });
+  }
+  for (const s of db.prepare(`SELECT ${expr} b, COUNT(*) n FROM sessions s ${w.sql} GROUP BY b`).all(...w.params)) {
+    if (s.b)
+      get(s.b).sessions = s.n;
+  }
+  for (const t of db.prepare(`SELECT ${expr} b, COUNT(*) n FROM turns tn JOIN sessions s ON s.id = tn.session_id ${w.sql} GROUP BY b`).all(...w.params)) {
+    if (t.b)
+      get(t.b).turns = t.n;
+  }
+  const series = [...byBucket.values()].sort((a, b) => a.bucket.localeCompare(b.bucket));
+  for (const r of series)
+    r.cost = Number(r.cost.toFixed(4));
+  return { bucket, series };
+}
+function dashboardBreakdowns(db, f) {
+  const w = sessionWhere(f);
+  const modelRows = db.prepare(`SELECT t.model model, SUM(t.input_tokens) i, SUM(t.output_tokens) o,
+              SUM(t.cache_creation_input_tokens) cw, SUM(t.cache_read_input_tokens) cr,
+              COUNT(DISTINCT t.session_id) sessions
+       FROM token_usage t JOIN sessions s ON s.id = t.session_id ${w.sql}
+       GROUP BY t.model ORDER BY (SUM(t.input_tokens)+SUM(t.output_tokens)+SUM(t.cache_creation_input_tokens)+SUM(t.cache_read_input_tokens)) DESC`).all(...w.params);
+  const byModel = modelRows.map((u) => ({
+    model: u.model,
+    tokens: { input: u.i ?? 0, output: u.o ?? 0, cache_creation: u.cw ?? 0, cache_read: u.cr ?? 0 },
+    total_tokens: (u.i ?? 0) + (u.o ?? 0) + (u.cw ?? 0) + (u.cr ?? 0),
+    cost: Number(costForUsage(u.model, { input_tokens: u.i, output_tokens: u.o, cache_creation_input_tokens: u.cw, cache_read_input_tokens: u.cr }).toFixed(4)),
+    sessions: u.sessions ?? 0,
+    priced: !!rateForModel(u.model)
+  }));
+  const bySource = db.prepare(`SELECT COALESCE(s.source_id, '(none)') source, COUNT(*) sessions, SUM(s.turn_count) turns
+       FROM sessions s ${w.sql} GROUP BY s.source_id ORDER BY sessions DESC`).all(...w.params);
+  const mainW = { sql: w.sql ? w.sql + " AND s.is_sidechain = 0" : "WHERE s.is_sidechain = 0", params: w.params };
+  const byCategory = db.prepare(`SELECT c.category, COUNT(*) n FROM classifications c JOIN sessions s ON s.id = c.target_id
+       ${mainW.sql} GROUP BY c.category ORDER BY n DESC`).all(...mainW.params);
+  const byComplexity = db.prepare(`SELECT c.complexity_band band, COUNT(*) n FROM classifications c JOIN sessions s ON s.id = c.target_id
+       ${mainW.sql} GROUP BY c.complexity_band ORDER BY n DESC`).all(...mainW.params);
+  const tools = db.prepare(`SELECT tc.tool_name name, COUNT(*) n FROM tool_calls tc JOIN sessions s ON s.id = tc.session_id
+       ${w.sql} GROUP BY tc.tool_name ORDER BY n DESC LIMIT 20`).all(...w.params);
+  const skills = db.prepare(`SELECT tc.skill_name name, COUNT(*) n FROM tool_calls tc JOIN sessions s ON s.id = tc.session_id
+       ${w.sql ? w.sql + " AND" : "WHERE"} tc.skill_name IS NOT NULL GROUP BY tc.skill_name ORDER BY n DESC LIMIT 20`).all(...w.params);
+  const skillVersions = db.prepare(`SELECT tc.skill_name name, sk.id version_id, sk.summary, sk.last_seen, COUNT(*) n
+       FROM tool_calls tc
+       JOIN skills sk ON sk.id = tc.skill_id
+       JOIN sessions s ON s.id = tc.session_id
+       ${w.sql ? w.sql + " AND" : "WHERE"} tc.skill_id IS NOT NULL
+       GROUP BY tc.skill_name, sk.id ORDER BY name, n DESC`).all(...w.params);
+  const subagentByType = db.prepare(`SELECT tc.agent_type type, COUNT(*) n FROM tool_calls tc JOIN sessions s ON s.id = tc.session_id
+       ${w.sql ? w.sql + " AND" : "WHERE"} tc.agent_type IS NOT NULL GROUP BY tc.agent_type ORDER BY n DESC`).all(...w.params);
+  const perSession = db.prepare(`SELECT COUNT(*) n FROM tool_calls tc JOIN sessions s ON s.id = tc.session_id
+       ${w.sql ? w.sql + " AND" : "WHERE"} s.is_sidechain = 0 AND tc.tool_name IN ('Agent','Task')
+       GROUP BY tc.session_id`).all(...w.params);
+  const counts = perSession.map((r) => r.n);
+  const subagentFanout = {
+    by_type: subagentByType,
+    sessions_with_subagents: counts.length,
+    total_spawns: counts.reduce((a, b) => a + b, 0),
+    max_per_session: counts.length ? Math.max(...counts) : 0,
+    avg_per_session: counts.length ? Number((counts.reduce((a, b) => a + b, 0) / counts.length).toFixed(2)) : 0
+  };
+  return { by_model: byModel, by_source: bySource, by_category: byCategory, by_complexity: byComplexity, tools, skills, skill_versions: skillVersions, subagent_fanout: subagentFanout };
+}
+
+// ../server/dist/refresh.js
+import { existsSync as existsSync5, mkdirSync as mkdirSync5 } from "fs";
+import { join as join6 } from "path";
+function originAllowed(origin) {
+  if (!origin)
+    return true;
+  try {
+    const h = new URL(origin).hostname;
+    return h === "127.0.0.1" || h === "localhost" || h === "::1";
+  } catch {
+    return false;
+  }
+}
+function runRefresh() {
+  const dataDir = resolveDataDir(findRepoRoot());
+  const lock = acquireLock(join6(dataDir, ".agent-lens.lock"));
+  if (!lock)
+    return null;
+  try {
+    const collected = collectAll();
+    const archiveRoot = process.env.AGENT_LENS_ARCHIVE || join6(dataDir, "archive");
+    if (!existsSync5(archiveRoot))
+      mkdirSync5(archiveRoot, { recursive: true });
+    runIngest([]);
+    return { ok: true, collected };
+  } finally {
+    lock.release();
+  }
+}
+
+// ../server/dist/app.js
+async function createApp(db, opts = {}) {
+  const app = Fastify({ logger: false });
+  app.get("/api/health", async () => ({ ok: true, last_ingested: lastIngested(db) }));
+  app.post("/api/refresh", async (req, reply) => {
+    if (!originAllowed(req.headers.origin)) {
+      return reply.code(403).send({ error: { code: "FORBIDDEN_ORIGIN", message: "cross-origin refresh blocked" } });
+    }
+    let result;
+    try {
+      result = runRefresh();
+    } catch (e) {
+      return reply.code(500).send({ error: { code: "REFRESH_FAILED", message: String(e?.message ?? e) } });
+    }
+    if (!result) {
+      return reply.code(409).send({ error: { code: "REFRESH_IN_PROGRESS", message: "a collect/ingest run is already in progress" } });
+    }
+    return { ok: true, collected: result.collected, last_ingested: lastIngested(db) };
+  });
+  app.get("/api/sources", async () => listSources(db));
+  app.get("/api/projects", async () => listProjects(db));
+  app.get("/api/models", async () => listModels(db));
+  const dashFilters = (req) => {
+    const q = req.query;
+    return { source: q.source, from: q.from, to: q.to };
+  };
+  app.get("/api/dashboard/overview", async (req) => dashboardOverview(db, dashFilters(req)));
+  app.get("/api/dashboard/timeseries", async (req) => {
+    const q = req.query;
+    return dashboardTimeseries(db, dashFilters(req), q.bucket);
+  });
+  app.get("/api/dashboard/breakdowns", async (req) => dashboardBreakdowns(db, dashFilters(req)));
+  app.get("/api/sessions", async (req) => {
+    const q = req.query;
+    return listSessions(db, {
+      source: q.source,
+      project: q.project,
+      model: q.model,
+      q: q.q,
+      from: q.from,
+      to: q.to,
+      kind: q.kind === "main" || q.kind === "subagent" ? q.kind : void 0,
+      limit: Math.min(Number(q.limit) || 50, 200),
+      offset: Number(q.offset) || 0
+    });
+  });
+  app.get("/api/sessions/:id", async (req, reply) => {
+    const { id } = req.params;
+    const result = getSession(db, id);
+    if (!result)
+      return reply.code(404).send({ error: "not found" });
+    return result;
+  });
+  app.get("/api/workflows/:run_id", async (req, reply) => {
+    const { run_id } = req.params;
+    const result = getWorkflow(db, run_id);
+    if (!result)
+      return reply.code(404).send({ error: "not found" });
+    return result;
+  });
+  app.get("/api/skills", async (req) => {
+    const q = req.query;
+    return listSkills(db, { q: q.q, source: q.source, project: q.project });
+  });
+  app.get("/api/skills/:name", async (req, reply) => {
+    const { name } = req.params;
+    const result = getSkill(db, decodeURIComponent(name));
+    if (!result)
+      return reply.code(404).send({ error: "not found" });
+    return result;
+  });
+  app.get("/api/sessions/:id/export.md", async (req, reply) => {
+    const { id } = req.params;
+    const result = getSession(db, id);
+    if (!result)
+      return reply.code(404).send({ error: "not found" });
+    const s = result.session;
+    const events = result.events.map((e) => ({
+      type: e.type,
+      role: e.role,
+      timestamp: e.timestamp,
+      text: e.text,
+      thinking: e.thinking,
+      toolCalls: e.toolCalls.map((t) => ({
+        tool_name: t.tool_name,
+        skill_name: t.skill_name,
+        agent_type: t.agent_type,
+        input_json: t.input_json,
+        status: t.status
+      }))
+    }));
+    const md = sessionToMarkdown({
+      id: s.id,
+      title: s.title,
+      source: s.source_id,
+      project: s.project_path,
+      model: null,
+      started_at: s.started_at,
+      ended_at: s.ended_at
+    }, events);
+    reply.header("content-type", "text/markdown; charset=utf-8").header("content-disposition", `attachment; filename="session-${id.slice(0, 8)}.md"`).send(md);
+  });
+  if (opts.webDist && existsSync6(opts.webDist)) {
+    await app.register(fastifyStatic, { root: opts.webDist });
+    app.setNotFoundHandler((req, reply) => {
+      if (req.url.startsWith("/api/"))
+        return reply.code(404).send({ error: "not found" });
+      return reply.sendFile("index.html");
+    });
+  }
+  return app;
+}
+
+// ../server/dist/run.js
+async function startServer() {
+  const here = dirname5(fileURLToPath2(import.meta.url));
+  const repoRoot = findRepoRoot(here);
+  const dbPath = process.env.AGENT_LENS_DB || join7(resolveDataDir(repoRoot), "agent-lens.db");
+  const host = process.env.AGENT_LENS_HOST || "127.0.0.1";
+  const port = Number(process.env.AGENT_LENS_PORT || 4477);
+  const webDist = resolveWebDist(here, repoRoot);
+  if (host !== "127.0.0.1" && host !== "localhost" && !process.env.AGENT_LENS_ALLOW_NONLOCAL) {
+    console.error(`agent-lens-server: refusing to bind non-loopback host '${host}' (privacy). Set AGENT_LENS_ALLOW_NONLOCAL=1 to override.`);
+    process.exit(1);
+  }
+  if (!existsSync7(dbPath)) {
+    console.error(`agent-lens-server: db not found: ${dbPath} (run ingest first)`);
+    process.exit(1);
+  }
+  const db = openReadonly(dbPath);
+  const app = await createApp(db, { webDist });
+  try {
+    await app.listen({ host, port });
+    console.log(`agent-lens-server: http://${host}:${port}  (db: ${dbPath})`);
+    if (!existsSync7(webDist))
+      console.log("  note: web SPA not built \u2014 run `pnpm --filter @agent-lens/web build`");
+  } catch (err) {
+    console.error(err);
+    process.exit(1);
+  }
+}
+
+// src/watch.ts
+import { existsSync as existsSync8 } from "fs";
+import { join as join8 } from "path";
+import chokidar from "chokidar";
+async function runWatch(opts = {}) {
+  const sources = loadSources();
+  const lockPath = join8(resolveDataDir(findRepoRoot()), ".agent-lens.lock");
+  let running = false;
+  let pending = false;
+  const cycle = () => {
+    if (running) {
+      pending = true;
+      return;
+    }
+    running = true;
+    const lock = acquireLock(lockPath);
+    if (!lock) {
+      running = false;
+      console.error("agent-lens watch: another collect/ingest run is in progress \u2014 skipping this cycle");
+      return;
+    }
+    try {
+      const stats = collectAll({ sources });
+      console.log(
+        `agent-lens watch: collected ${stats.scanned} files (${stats.appended} appended, ${stats.snapshots} snapshots) \u2014 ingesting`
+      );
+      runIngest([]);
+    } catch (e) {
+      console.error("agent-lens watch: cycle failed:", e);
+    } finally {
+      lock.release();
+      running = false;
+      if (pending) {
+        pending = false;
+        setTimeout(cycle, 0);
+      }
+    }
+  };
+  cycle();
+  const watchPaths = sources.map((s) => join8(s.configDir, "projects")).filter((p) => existsSync8(p));
+  if (watchPaths.length === 0) {
+    console.error("agent-lens watch: no source 'projects' directories found \u2014 nothing to watch");
+  }
+  const watcher = chokidar.watch(watchPaths, {
+    ignoreInitial: true,
+    usePolling: !!opts.poll,
+    awaitWriteFinish: { stabilityThreshold: 500, pollInterval: 100 }
+  });
+  let debounce = null;
+  const trigger = () => {
+    if (debounce) clearTimeout(debounce);
+    debounce = setTimeout(cycle, 3e3);
+  };
+  watcher.on("add", trigger).on("change", trigger);
+  if (opts.intervalSec && opts.intervalSec > 0) {
+    setInterval(cycle, opts.intervalSec * 1e3);
+  }
+  console.log(
+    `agent-lens watch: watching ${watchPaths.length} source dir(s)` + (opts.intervalSec ? ` + every ${opts.intervalSec}s` : "") + " \u2014 Ctrl-C to stop"
+  );
+  return new Promise(() => {
+  });
+}
+
+// src/index.ts
+function version() {
+  try {
+    const pkg = JSON.parse(readFileSync5(join9(dirname6(fileURLToPath3(import.meta.url)), "../package.json"), "utf8"));
+    return pkg.version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+function withLock(fn) {
+  const lockPath = join9(resolveDataDir(findRepoRoot()), ".agent-lens.lock");
+  const lock = acquireLock(lockPath);
+  if (!lock) {
+    console.error("agent-lens: another collect/ingest run is in progress \u2014 skipping");
+    return;
+  }
+  try {
+    fn();
+  } finally {
+    lock.release();
+  }
+}
+var cli = cac("agent-lens");
+cli.command("collect", "Copy new session traces into the local archive").option("--then-ingest", "Run ingest immediately after collecting").action((opts) => {
+  withLock(() => {
+    const s = collectAll();
+    console.log(
+      `agent-lens: collect done \u2014 ${s.sources} source(s), ${s.scanned} scanned, ${s.copied} copied, ${s.appended} appended, ${s.diverged} diverged, ${s.compacted} compacted, ${s.snapshots} snapshots`
+    );
+    if (opts.thenIngest) runIngest([]);
+  });
+});
+cli.command("ingest", "Build/update the SQLite projection from the archive").option("--full", "Ignore incremental state and re-read every file").option("--db <path>", "SQLite DB path").option("--archive <path>", "Archive directory").action((opts) => {
+  const argv = [];
+  if (opts.full) argv.push("--full");
+  if (opts.db) argv.push("--db", opts.db);
+  if (opts.archive) argv.push("--archive", opts.archive);
+  withLock(() => runIngest(argv));
+});
+cli.command("serve", "Serve the web UI + read-only API on 127.0.0.1").action(async () => {
+  await startServer();
+});
+cli.command("watch", "Watch sources and collect + ingest on change (resident process)").option("--interval <sec>", "Also run on a fixed interval (seconds)").option("--poll", "Use polling \u2014 for network filesystems where fs events don't fire").action(async (opts) => {
+  await runWatch({ intervalSec: opts.interval ? Number(opts.interval) : void 0, poll: !!opts.poll });
+});
+cli.command("metrics", "Re-run classification over an already-ingested DB").option("--db <path>", "SQLite DB path").action((opts) => {
+  runMetrics(opts.db ? ["--db", opts.db] : []);
+});
+cli.command(
+  "service <action> [target]",
+  "Install/uninstall/status OS services \u2014 action: install|uninstall|status; target: collector|server|all (default all)"
+).option("--times <hours>", "Collector cadence: comma-separated hours 0-23 (default: 9,13,17,21)").action((action, target, opts) => {
+  const targets = parseTargets(target);
+  const hours = action === "install" ? parseHours(opts.times) : void 0;
+  runService(action, { cliEntry: fileURLToPath3(import.meta.url), hours, targets });
+});
+cli.help();
+cli.version(version());
+cli.parse();
+//# sourceMappingURL=agent-lens.js.map