fapony 0.3.3 → 0.3.5

package/src/price/resolve.ts

@@ -1,213 +1,12 @@
-// src/price/resolve.ts — normalize model id + compute list-price equivalent
-//
-// Hard rule: an unmappable model must be unpriced, never silently counted as 0 (the main failure mode
-// of this feature) · free only applies to things that truly cost 0 (local / :free rows in the table)
-
-import type { ModelBreakdown, PassiveUsageResult } from "../session/types.js";
-import type { ModelRates, PriceTable } from "./fetch.js";
-
-export type PriceStatus = "priced" | "free" | "unpriced";
-
-export interface PriceResolution {
-  status: PriceStatus;
-  rates: ModelRates | null;
-}
-
-/** client prefix prepended to every model id — strip it, then look up again */
-const CLIENT_PREFIXES = ["openrouter/", "opencode-go/", "opencode/"];
-
-/** OpenRouter's trailing tier — :free is a genuinely free endpoint, :batch is a discount */
-function stripTier(id: string): string {
-  return id.endsWith(":free") || id.endsWith(":batch")
-    ? id.slice(0, id.lastIndexOf(":"))
-    : id;
-}
-
-/**
- * Candidate ids ordered by specificity: exact first, broad later
- * (an exact match always wins — the bare slug is the broadest match and goes last)
- */
-export function candidateIds(provider: string, model: string): string[] {
-  const full = provider ? `${provider}/${model}` : model;
-  const out: string[] = [full];
-  let rest = full;
-  for (const p of CLIENT_PREFIXES) {
-    if (rest.startsWith(p)) {
-      rest = rest.slice(p.length);
-      out.push(rest);
-      break;
-    }
-  }
-  // opencode appends -free to the slug of a free model (deepseek-v4-flash-free)
-  if (rest.endsWith("-free")) out.push(rest.slice(0, -"-free".length));
-  return out;
-}
-
-/**
- * Find rates for one model — null only for local, which skips the table
- * (local never had a price to begin with, it is not "not found")
- */
-function isLocalProvider(provider: string): boolean {
-  return provider === "lmstudio_local";
-}
-
-export function resolvePrice(
-  provider: string,
-  model: string,
-  table: PriceTable,
-): PriceResolution {
-  if (!model || model === "(no model id)" || model === "(unknown)")
-    return { status: "unpriced", rates: null };
-  if (isLocalProvider(provider)) return { status: "free", rates: null };
-  // ends with :free or -free = used a free endpoint / the client's free model
-  // the real price is 0 (not list price), whether or not OpenRouter maps it
-  if (model.endsWith(":free") || model.endsWith("-free"))
-    return { status: "free", rates: null };
-  for (const id of candidateIds(provider, model)) {
-    const rates = table.models[id] ?? table.models[stripTier(id)];
-    if (rates) {
-      // an all-zero rate row (:free / free model) = genuinely free, not unpriced
-      if (
-        rates.input === 0 &&
-        rates.output === 0 &&
-        rates.cacheRead === 0 &&
-        (rates.cacheWrite ?? 0) === 0
-      )
-        return { status: "free", rates };
-      return { status: "priced", rates };
-    }
-  }
-  // zcode stores only the slug with no vendor (GLM-5.3-Flash) — compare the suffix / exact
-  // case-insensitive match (exact, not fuzzy: the whole string must be equal in length)
-  // the table side strips the tier (:free/:batch) before comparing — so a bare slug hits the :free
-  // row that is truly 0 (e.g. ling-3.0-flash-fin) and becomes free, not unpriced
-  const slug = stripTier(
-    candidateIds(provider, model).at(-1) ?? "",
-  ).toLowerCase();
-  if (slug) {
-    const ids = Object.keys(table.models).sort();
-    for (const id of ids) {
-      const rawSuffix = id.includes("/")
-        ? id.slice(id.lastIndexOf("/") + 1)
-        : id;
-      if (stripTier(rawSuffix).toLowerCase() === slug) {
-        const rates = table.models[id];
-        if (
-          rates.input === 0 &&
-          rates.output === 0 &&
-          rates.cacheRead === 0 &&
-          (rates.cacheWrite ?? 0) === 0
-        )
-          return { status: "free", rates };
-        return { status: "priced", rates };
-      }
-    }
-  }
-  return { status: "unpriced", rates: null };
-}
-
-export interface TokenCounts {
-  input: number;
-  cacheRead: number;
-  cacheWrite: number;
-  output: number;
-}
-
-/**
- * Pure costing: separate rates for input / cache-read / cache-write — never one rate for all
- *
- * reasoning is not multiplied separately: Anthropic-family thinking is already included in output
- * (the reader keeps it separately just for visibility); multiplying separately = double counting · cache_write absent from the table
- * → fall back to the input rate (writing cache costs more than or equal to a fresh read, never less)
- */
-export function calcCost(t: TokenCounts, rates: ModelRates): number {
-  return (
-    t.input * rates.input +
-    t.cacheRead * rates.cacheRead +
-    t.cacheWrite * (rates.cacheWrite ?? rates.input) +
-    t.output * rates.output
-  );
-}
-
-export interface ImputedModel {
-  provider: string;
-  model: string;
-  session_count: number;
-  tokens_input: number;
-  tokens_output: number;
-  tokens_cache_read: number;
-  tokens_cache_write: number;
-  status: PriceStatus;
-  /** dollars at list-price — 0 when free/unpriced (check status, do not read the number alone) */
-  imputed_cost: number;
-}
-
-export interface ImputeSummary {
-  total_imputed: number;
-  priced_sessions: number;
-  free_sessions: number;
-  unpriced_sessions: number;
-  unpriced_tokens: number;
-  by_model: ImputedModel[];
-}
-
-/**
- * Price an entire PassiveUsageResult — works on live results (stats/usage) or cache rows
- * (usage-web) alike, because it only takes tokens per model
- */
-export function imputeResult(
-  result: PassiveUsageResult,
-  table: PriceTable,
-): ImputeSummary {
-  const by_model: ImputedModel[] = [];
-  let total_imputed = 0;
-  let priced_sessions = 0;
-  let free_sessions = 0;
-  let unpriced_sessions = 0;
-  let unpriced_tokens = 0;
-  for (const m of result.by_model as ModelBreakdown[]) {
-    const r = resolvePrice(m.provider, m.model, table);
-    let cost = 0;
-    if (r.status === "priced" && r.rates) {
-      cost = calcCost(
-        {
-          input: m.tokens_input,
-          cacheRead: m.tokens_cache_read,
-          cacheWrite: m.tokens_cache_write,
-          output: m.tokens_output,
-        },
-        r.rates,
-      );
-      total_imputed += cost;
-      priced_sessions += m.session_count;
-    } else if (r.status === "free") {
-      free_sessions += m.session_count;
-    } else {
-      unpriced_sessions += m.session_count;
-      unpriced_tokens +=
-        m.tokens_input +
-        m.tokens_output +
-        m.tokens_cache_read +
-        m.tokens_cache_write;
-    }
-    by_model.push({
-      provider: m.provider,
-      model: m.model,
-      session_count: m.session_count,
-      tokens_input: m.tokens_input,
-      tokens_output: m.tokens_output,
-      tokens_cache_read: m.tokens_cache_read,
-      tokens_cache_write: m.tokens_cache_write,
-      status: r.status,
-      imputed_cost: cost,
-    });
-  }
-  return {
-    total_imputed,
-    priced_sessions,
-    free_sessions,
-    unpriced_sessions,
-    unpriced_tokens,
-    by_model,
-  };
-}
+// shim — moved to src/core/pricing.ts
+export {
+  calcCost,
+  candidateIds,
+  type ImputedModel,
+  type ImputeSummary,
+  imputeResult,
+  type PriceResolution,
+  type PriceStatus,
+  resolvePrice,
+  type TokenCounts,
+} from "../core/pricing.js";

package/src/report/cli.ts

@@ -3,9 +3,9 @@
 import { spawnSync } from "node:child_process";
 import { writeFileSync } from "node:fs";
 import { dirname, resolve } from "node:path";
-import { loadConfig } from "../db/index.js";
-import { toolVerificationReport } from "../mcp/tools/report.js";
-import { parseToolResult } from "../mcp/types.js";
+import { toolVerificationReport } from "../adapters/mcp/tools/report.js";
+import { loadConfig } from "../core/config.js";
+import { parseToolResult } from "../core/types.js";
 import { getStatsData } from "../stats/data.js";
 import { renderReportHtml } from "./render.js";
 

package/src/safety.ts

@@ -1,18 +1,2 @@
-// src/safety.ts — deny-list for dangerous git commands.
-// Rule: assertSafe() must be called on every command before spawn, including
-// ones built from config templates (memory claim/close/add, evidence
-// collector commands, install's `claude mcp add`).
-// Patterns come from config.safety.deny (regex sources); built-in default
-// covers the 4 known-destructive git invocations.
-
-import { DEFAULT_SAFETY_DENY } from "./db/index.js";
-
-export function assertSafe(argv: string[], denySources?: string[]): void {
-  const sources = denySources ?? DEFAULT_SAFETY_DENY;
-  const joined = argv.join(" ");
-  for (const src of sources) {
-    if (new RegExp(src).test(joined)) {
-      throw new Error(`refusing to run dangerous command: ${joined}`);
-    }
-  }
-}
+// shim — moved to src/core/safety.ts
+export { assertSafe } from "./core/safety.js";

package/src/seed/plan-seed.ts

@@ -35,14 +35,16 @@ import {
 } from "node:fs";
 import { basename, join, relative, resolve, sep } from "node:path";
 import { collectSourceFiles, isSkippedDir, SCAN_EXTS } from "../analyze.js";
-import { computeModelFit } from "../context/projectHealth.js";
-import { doneDir, planDir, specDir } from "../db/getters.js";
-import { CONFIG_FILENAME } from "../db/index.js";
-import { loadConfig } from "../db/load.js";
-import type { Config } from "../db/types.js";
+import {
+  CONFIG_FILENAME,
+  type Config,
+  doneDir,
+  loadConfig,
+  planDir,
+  specDir,
+} from "../core/config.js";
 import { extractExports } from "../map.js";
 import { readRecentMemDecisions } from "../memory.js";
-import { getStatsData } from "../stats/data.js";
 import { capLines, execGit, SIG_MAX } from "./primitives.js";
 
 // One chunk = one module's signatures — past ~40 lines a module is its own
@@ -56,6 +58,14 @@ const SCOPE_WARN_FILES = 300;
 // Shipped plans/specs that already touched this scope. Capped low on purpose:
 // this is a "go read that first" pointer, not a bibliography.
 const MAX_PRIOR_ART = 5;
+// Chunk 4 (PLAN-seed-and-surface): the PLAN names what is already in scope —
+// one line per scope file with its export names. SPEC-only seeds never gave
+// PLAN-only readers this pointer, so agents re-derived what export-lines.ts
+// already knew. Capped low: a pointer, not a signature dump.
+const MAX_EXISTING_IN_SCOPE = 15;
+// The PLAN ≤ ~60 contract (§3.1) predates this block — the block yields to it,
+// never grows it. Effective block cap = min(block cap, remaining budget).
+const MAX_PLAN_LINES = 60;
 // Anchor-safe slug: lowercase, non-alphanumerics → dash.
 const slug = (s: string): string =>
   s
@@ -145,7 +155,84 @@ function renderPriorArt(cwd: string, config: Config, roots: string[]): string {
   return shown.join("\n");
 }
 
-// --- Context (fapony): mem decisions + model fit ---
+// Chunk 5 (PLAN-seed-and-surface): stdout ends with the plans that already
+// exist — the seed that lands next to a shipped decision without knowing it
+// is the expensive mistake (§8 prior art guards the file, this guards the
+// glance). Active plans first (the ones a new seed must not duplicate),
+// then shipped; capped like every other list here.
+const MAX_PLAN_LIST = 10;
+
+function listExistingPlans(
+  cwd: string,
+  config: Config,
+  exclude: string,
+): string[] {
+  const items: string[] = [];
+  for (const [dir, where] of [
+    [planDir(), "plan"],
+    [doneDir(config), "done"],
+  ] as const) {
+    let names: string[];
+    try {
+      names = readdirSync(join(cwd, dir))
+        .filter((n) => n.endsWith(".md"))
+        .sort();
+    } catch {
+      continue; // dir missing — nothing seeded yet
+    }
+    for (const n of names) {
+      if (n === exclude) continue; // the file just written, not "existing"
+      items.push(`- ${n} (${where})`);
+    }
+  }
+  if (items.length === 0) return ["- (none yet)"];
+  return capLines(items, MAX_PLAN_LIST, "plans");
+}
+
+// --- Context (fapony): mem decisions + existing in scope ---
+//
+// No ledger-ranking line here (PLAN-seed-and-surface chunk 6): the ledger is
+// frozen and Positioning rule 2 forbids cross-model ranking claims, so a
+// seeded pointer at it teaches the reader to cite what cannot be cited.
+// computeModelFit() itself stays — `fapony stats` reads it.
+
+// One line per scope file naming its exports — `src/debt/scan.ts —
+// scanDebt() · DebtHit`. Files with no exports (or unreadable) are skipped:
+// a pointer lists what is there, not what is not. Sorted for determinism.
+function renderExistingInScope(
+  roots: string[],
+  cwd: string,
+  scoped: boolean,
+  cap: number,
+): string[] {
+  // No --scope means every file in the repo matches — a list of everything
+  // points at nothing (§8 prior art goes quiet for the same reason).
+  if (!scoped)
+    return ["- _(no --scope — re-seed with --scope <dir> to list exports)_"];
+  const abs: string[] = [];
+  for (const r of roots) for (const f of scopeSourceFiles(r)) abs.push(f);
+  const rels = [...new Set(abs.map((f) => relative(cwd, f) || "."))].sort();
+  const lines: string[] = [];
+  for (const rel of rels) {
+    let source: string;
+    try {
+      source = readFileSync(join(cwd, rel), "utf-8");
+    } catch {
+      continue;
+    }
+    const scan = extractExports(source);
+    if (scan.error || scan.symbols.length === 0) continue;
+    // Re-export-only files scan as one `*` per line — dedupe to a single `*`.
+    const names = [
+      ...new Set(
+        scan.symbols.map((s) => (s.kind === "fn" ? `${s.name}()` : s.name)),
+      ),
+    ];
+    lines.push(`- ${rel} — ${names.join(" · ")}`);
+  }
+  if (lines.length === 0) return ["- _(no exports in scope)_"];
+  return capLines(lines, cap, "files in scope (narrow with --scope <path>)");
+}
 
 function renderContextFapony(worktree: string): string {
   const lines: string[] = [];
@@ -160,17 +247,6 @@ function renderContextFapony(worktree: string): string {
           .join(" · ")}`
       : "- Decisions on record (mem): _(none — no mem log or empty)_",
   );
-  const fits = computeModelFit(getStatsData().byRegime, worktree);
-  lines.push(
-    fits.length > 0
-      ? `- Model fit (ledger, min N=5): ${fits
-          .map(
-            (f) =>
-              `${f.regime} → ${f.model} (N=${f.gates}, fail ${(f.failRate * 100).toFixed(0)}%)`,
-          )
-          .join(" · ")}`
-      : "- Model fit: _(not enough graded history yet)_",
-  );
   return lines.join("\n");
 }
 
@@ -180,6 +256,7 @@ function planTemplate(
   name: string,
   priorArt: string,
   contextFapony: string,
+  existingScope: string[],
   specLink: string | null,
   planRel: string,
 ): string {
@@ -200,6 +277,8 @@ status: active
 
 ## Context (fapony)
 ${contextFapony}
+### Existing in scope
+${existingScope.join("\n")}
 
 ## 1. Goal (why)
 _(agent fills in)_
@@ -217,19 +296,11 @@ _(agent fills in)_
 _(agent fills in)_
 
 ## 6. Steps (what in which order)
-One step = one chunk = one session: finish it, close it, **stop** — starting the
-next step in the same session is what rule 9 forbids.
+One step = one chunk = one session: finish it, close it, **stop** — starting the next step in the same session is what rule 9 forbids.
 
 1. _(agent fills in — each step must be verifiable)_
 
-**Closing a step:** tick its TL;DR box with the sha · \`git commit\` this step's
-files only · then hand off:
-
-\`\`\`bash
-fapony mem add note "<what chunk N+1 must know>" --files <f1,f2> ${planRel}
-\`\`\`
-
-Next session opens with \`kickoff ${planRel}\` (or \`kickoff ${basename(planRel)}\` — kickoff resolves by filename too, so no need to retype the path).
+**Closing a step:** tick TL;DR with sha · \`git commit\` files only · \`fapony mem add note "<what chunk N+1 must know>" --files <f1,f2> ${planRel}\` · next opens with \`kickoff ${planRel}\` (or \`kickoff PLAN-${name}.md\` — kickoff resolves by filename too).
 
 ## 7. Examples
 ${
@@ -562,6 +633,14 @@ export function cmdPlanSeed(args: string[]): void {
 
   const priorArt = renderPriorArt(cwd, config, roots);
   const contextFapony = renderContextFapony(worktree);
+  const scoped = requested.length > 0;
+  // First pass at the block cap — the total-cap check below may shrink it.
+  let existingScope = renderExistingInScope(
+    roots,
+    cwd,
+    scoped,
+    MAX_EXISTING_IN_SCOPE,
+  );
 
   let specLink: string | null = null;
   if (withSpec) {
@@ -589,15 +668,30 @@ export function cmdPlanSeed(args: string[]): void {
   }
 
   mkdirSync(planDirAbs, { recursive: true });
-  writeFileSync(
-    planPath,
+  const buildPlan = (existing: string[]): string =>
     planTemplate(
       name,
       priorArt,
       contextFapony,
+      existing,
       specLink,
       `${planDir()}/PLAN-${name}.md`,
-    ),
-  );
+    );
+  let planBody = buildPlan(existingScope);
+  // The ≤ ~60 contract predates the §4 block — shrink the block (never the
+  // judgment sections) until the file fits. Each item is one line, so cutting
+  // `over` items fixes exactly; the re-render recounts the cut honestly.
+  const planLines = (b: string): number =>
+    b.replace(/\n$/, "").split("\n").length;
+  const over = planLines(planBody) - MAX_PLAN_LINES;
+  if (over > 0) {
+    const budget = Math.max(existingScope.length - over, 1);
+    existingScope = renderExistingInScope(roots, cwd, scoped, budget);
+    planBody = buildPlan(existingScope);
+  }
+  writeFileSync(planPath, planBody);
   console.log(`wrote ${planPath}${specLink ? ` + SPEC-${name}.md` : ""}`);
+  console.log("Existing plans:");
+  for (const l of listExistingPlans(cwd, config, `PLAN-${name}.md`))
+    console.log(l);
 }

package/src/seed/primitives.ts

@@ -53,13 +53,7 @@ export function gitValue(kind: string, value: string): string {
 
 // Keep the head, always say how much was cut — a silent cut is
 // indistinguishable from "that was everything".
-export function capLines(lines: string[], cap: number, what: string): string[] {
-  if (lines.length <= cap) return lines;
-  const rest = lines.length - (cap - 1);
-  const kept = lines.slice(0, cap - 1);
-  kept.push(`… +${rest} more ${what}`);
-  return kept;
-}
+export { capLines } from "../core/util.js";
 
 // --- Signature formatting ---
 

package/src/session/types.ts

@@ -1,128 +1,14 @@
-// src/session/types.ts — shared types + constants for session usage providers
-
-export interface ModelBreakdown {
-  provider: string;
-  model: string;
-  session_count: number;
-  tokens_input: number;
-  tokens_output: number;
-  tokens_reasoning: number;
-  tokens_cache_read: number;
-  tokens_cache_write: number;
-  cost: number;
-}
-
-export interface SessionDetail {
-  session_id: string;
-  model: string;
-  steps: number;
-  tools: Record<string, number>;
-}
-
-export interface ToolLatencyStat {
-  count: number;
-  avgMs: number;
-}
-
-export interface StepTimingSummary {
-  /** step-finish row count (mirrors UsageDetail.steps for SQLite providers). */
-  steps: number;
-  /** Mean per-part duration from embedded data.time (row-timestamp fallback when absent). */
-  avgStepMs: number | null;
-  /** How many durations were actually measured (vs. steps with no time signal). */
-  stepSamples: number;
-  /** Mean per-step tokens — averages only, never summed (sums overlap). */
-  avgStepInput: number | null;
-  avgStepOutput: number | null;
-  avgStepCost: number | null;
-  /** Mean tool latency grouped by tool name (from data.state.time). */
-  toolLatencyMsByType: Record<string, ToolLatencyStat>;
-  note: string;
-}
-
-export interface StaleReadFile {
-  file: string;
-  /** How many distinct sessions read this file (diversity, not just count). */
-  sessions: number;
-  /** Total Read calls across those sessions. */
-  reads: number;
-}
-
-export interface UsageDetail {
-  /** Global tool-call counts across the filtered sessions (activity signal, not quality). */
-  tool_breakdown: Record<string, number>;
-  /** Context bytes per tool — size of tool_result content blocks. */
-  bytes_by_tool?: Record<string, number>;
-  /** Total step-finish parts across the filtered sessions. */
-  steps: number;
-  /** Per-session breakdown (SQL-aggregated, never raw part rows). */
-  by_session: SessionDetail[];
-  /**
-   * Files read across 2+ sessions in this window and never edited/written —
-   * candidates for pasting into CLAUDE.md instead of re-reading every
-   * session. Top 20 by session count. Needs a wide `since` window (many
-   * sessions) before the pattern means anything — noise below that.
-   */
-  stale_reads?: StaleReadFile[];
-  /**
-   * Step-token sums are NOT reported: per-step tokens overlap (each step
-   * carries the full context window), so SUM(step tokens) >> session tokens.
-   * Verified on real data — see testSessionDetailStepTokensNotSummed.
-   */
-  note: string;
-  /** Per-step timing/token/latency signal — present only when detail:true was requested. */
-  timing?: StepTimingSummary | null;
-}
-
-export interface PassiveUsageResult {
-  total_tokens_input: number;
-  total_tokens_output: number;
-  total_tokens_reasoning: number;
-  total_tokens_cache_read: number;
-  total_tokens_cache_write: number;
-  total_cost: number;
-  session_count: number;
-  by_model: ModelBreakdown[];
-  /** Present only when detail:true was requested (additive, default absent). */
-  detail?: UsageDetail | null;
-  /** ZCode sessions, when available. Absent when ZCode DB not found. */
-  zcode?: PassiveUsageResult | null;
-  /** Claude Code sessions, when available. Absent when projects dir not found. */
-  claude_code?: PassiveUsageResult | null;
-  /**
-   * Why this read came back short, when it did. Absent on success.
-   *
-   * Zeros with no `error` mean "no sessions matched"; zeros WITH an error mean
-   * "could not read the client's log" — most often schema drift after the
-   * client updated. The two used to be indistinguishable: a renamed column
-   * made the query throw, the catch-all swallowed it, and the numbers just
-   * quietly went missing.
-   */
-  error?: string;
-}
-
-export const EMPTY_RESULT: PassiveUsageResult = {
-  total_tokens_input: 0,
-  total_tokens_output: 0,
-  total_tokens_reasoning: 0,
-  total_tokens_cache_read: 0,
-  total_tokens_cache_write: 0,
-  total_cost: 0,
-  session_count: 0,
-  by_model: [],
-};
-
-/** Common shape every client reader implements — see registry.ts. */
-export type PassiveUsageReader = (
-  worktree?: string,
-  since?: number,
-  until?: number,
-  detail?: boolean,
-  full?: boolean,
-) => PassiveUsageResult;
-
-export const STEP_TOKENS_NOTE =
-  "step tokens overlap (per-step context window) — SUM(step tokens) != session tokens; steps is a count only";
-
-export const TIMING_NOTE =
-  "timing from embedded part fields only (data.time/data.state.time/step-finish tokens) with row-timestamp fallback; averages, never raw I/O";
+// shim — moved to src/core/types.ts
+export {
+  EMPTY_RESULT,
+  type ModelBreakdown,
+  type PassiveUsageReader,
+  type PassiveUsageResult,
+  type SessionDetail,
+  STEP_TOKENS_NOTE,
+  type StaleReadFile,
+  type StepTimingSummary,
+  TIMING_NOTE,
+  type ToolLatencyStat,
+  type UsageDetail,
+} from "../core/types.js";

package/src/setup.ts

@@ -6,7 +6,7 @@ import { existsSync, statSync, writeFileSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { createInterface } from "node:readline";
 import { seedConventionsFile } from "./conventions-seed.js";
-import { CONFIG_FILENAME, FAPONY_DIR } from "./db/index.js";
+import { CONFIG_FILENAME, FAPONY_DIR } from "./core/config.js";
 import { initProject } from "./init.js";
 import { isAffirmative } from "./util.js";
 

package/src/stats/data.ts

@@ -2,10 +2,10 @@
 
 import { readdirSync } from "node:fs";
 import { join } from "node:path";
-import { type Event, openDb, PLAN_DIR, type Run } from "../db/index.js";
-import { loadConfig } from "../db/load.js";
+import { type Event, loadConfig, PLAN_DIR, type Run } from "../core/config.js";
+import { REASON_CODES, REGIME_CODES } from "../core/enums.js";
+import { openDb } from "../db/store.js";
 import { enrichGateWindows } from "../gates.js";
-import { REASON_CODES, REGIME_CODES } from "../mcp/types.js";
 import {
   isPassFamily,
   qualityScore,

package/src/telemetry.ts

@@ -13,9 +13,9 @@ import {
   type Config,
   type Event,
   loadConfig,
-  openDb,
   type Run,
-} from "./db/index.js";
+} from "./core/config.js";
+import { openDb } from "./db/store.js";
 import { enrichGateWindows } from "./gates.js";
 import { readPassiveUsage } from "./session/index.js";
 import { avg, minutesBetween } from "./util.js";