fapony 0.1.2 → 0.2.0

package/src/mem/store.ts

@@ -0,0 +1,348 @@
+// store.ts — types + config + read/write primitives for the append-only memory log
+//
+// Moved from templates/mem/store.ts (2026-09-19) as part of PLAN-agent-one-call chunk 1.
+// The template was copied into every repo via `fapony init-mem`; now fapony owns the code
+// and calls it directly via `fapony mem <sub>`. Path resolution is no longer based on
+// import.meta.dir — initStore() receives the worktree explicitly from the CLI dispatch.
+
+import { createHash } from "node:crypto";
+import {
+  appendFileSync,
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+} from "node:fs";
+import { hostname, networkInterfaces } from "node:os";
+import { basename, dirname, join, relative } from "node:path";
+import { whereMemDir } from "../memory.js";
+
+// --- types ---
+
+type WorkKind = "next" | "bug" | "decision" | "note" | "hold";
+
+type WorkRow = {
+  ts: string;
+  agent: string;
+  id: string;
+  kind: WorkKind;
+  text: string;
+  spec?: string;
+  files?: string[];
+};
+
+type CloseRow = {
+  ts: string;
+  agent: string;
+  kind: "close";
+  ref: string;
+  text: string;
+};
+
+type ClaimRow = {
+  ts: string;
+  agent: string;
+  kind: "claim";
+  ref: string;
+};
+
+type ReleaseRow = {
+  ts: string;
+  agent: string;
+  kind: "release";
+  ref: string;
+  text?: string;
+};
+
+type SyncedRow = {
+  ts: string;
+  agent: string;
+  kind: "synced";
+  spec: string;
+};
+
+type LogRow = WorkRow | CloseRow | ClaimRow | ReleaseRow | SyncedRow;
+
+// --- identity ---
+//
+// `agent` goes in every row, `person` names the file. Both used to end in
+// "unknown", which is not a fallback: two machines with no git and no $USER
+// wrote the same filename and their rows interleaved with no way to tell them
+// apart. Generic OS accounts collide the same way — `admin`/`user`/`owner` are
+// what a fresh install offers, so treat them as absent rather than as a name.
+// git user.email is unique by construction; the machine tag is the last resort,
+// hashed because this file is committed and a raw MAC address is not ours to
+// publish. user.email is only spawned when the cheap sources fail — initStore
+// sits on the mem_add hot path (git config ≈ 12ms).
+
+const GENERIC_NAMES = new Set([
+  "admin",
+  "user",
+  "owner",
+  "root",
+  "ubuntu",
+  "ec2-user",
+  "vagrant",
+  "dev",
+  "developer",
+  "node",
+  "unknown",
+]);
+
+const usable = (v: string | null | undefined): string | null => {
+  const s = (v ?? "").trim();
+  return s && !GENERIC_NAMES.has(s.toLowerCase()) ? s : null;
+};
+
+// `env: process.env` is not redundant: Bun.spawnSync snapshots the environment
+// at startup, so a variable set at runtime (GIT_CONFIG_GLOBAL in a test, MEM_*
+// set by a wrapper) never reaches the child without passing it explicitly.
+const gitConfig = (key: string, cwd: string): string | null =>
+  Bun.spawnSync(["git", "config", key], { cwd, env: process.env })
+    .stdout.toString()
+    .trim() || null;
+
+function machineSeed(): string {
+  try {
+    const id = readFileSync("/etc/machine-id", "utf8").trim();
+    if (id) return id;
+  } catch {
+    // no /etc/machine-id (macOS) — fall through to the interface list
+  }
+  for (const ifaces of Object.values(networkInterfaces()))
+    for (const i of ifaces ?? [])
+      if (!i.internal && i.mac && i.mac !== "00:00:00:00:00:00") return i.mac;
+  return hostname();
+}
+
+const machineTag = (): string =>
+  `m-${createHash("sha256").update(machineSeed()).digest("hex").slice(0, 8)}`;
+
+const slug = (v: string): string =>
+  v
+    .toLowerCase()
+    .replace(/[^a-z0-9._-]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+
+// --- mutable state (populated by initStore) ---
+
+let root = "";
+let dir = "";
+let planDir = "";
+let doneDir = "";
+let agent = "";
+let person = "";
+let LOG = "";
+let memCmd = "";
+let planBase = "";
+let app = "";
+// Non-empty when the resolver found two or more app-scoped mem dirs and no
+// single one at/above cwd — a write must die rather than start a third log.
+let blockWrite = "";
+
+// --- init ---
+
+/**
+ * Initialize the store for a given worktree. Must be called before using any
+ * export. The CLI dispatch layer calls this with the resolved worktree path.
+ *
+ * `overrideMemDir` (from --mem-dir flag) skips resolution entirely.
+ * Otherwise whereMemDir() walks up from cwd — the same dir the reader
+ * (src/memory.ts) uses, so writer and reader cannot drift apart.
+ */
+export function initStore(worktree: string, overrideMemDir?: string): void {
+  root = Bun.spawnSync(["git", "rev-parse", "--show-toplevel"], {
+    cwd: worktree,
+  })
+    .stdout.toString()
+    .trim();
+  if (!root) root = worktree;
+
+  // An explicit --mem-dir is a promise: never silently fall back to the
+  // default when the path is wrong, or the row lands in a log nobody reads.
+  if (overrideMemDir && !existsSync(overrideMemDir)) {
+    throw new Error(`--mem-dir path does not exist: ${overrideMemDir}`);
+  }
+
+  // Resolution and the CLI's `mem where` share one function, so the path a row
+  // is written to is the path `mem where` reports.
+  blockWrite = "";
+  const resolved = whereMemDir(worktree, overrideMemDir);
+  if (resolved.step === "ambiguous") {
+    const list = (resolved.candidates ?? []).map((c) => `  ${c}`).join("\n");
+    blockWrite =
+      `two or more .fapony/.memory dirs under ${root} — refusing to guess:\n` +
+      `${list}\ncd into one, set paths.memDir, or pass --mem-dir`;
+  }
+  dir = resolved.dir ?? join(root, ".fapony", ".memory");
+
+  // planBase: the .fapony dir — plan/done/conventions live here.
+  // Derive from dir by going up from .fapony/.memory → .fapony
+  planBase = dirname(dir);
+
+  // app name for display — the directory containing .fapony
+  app = dirname(planBase);
+
+  // Read fapony.config.json
+  const configDir = planBase === `${root}/.fapony` ? root : dirname(planBase);
+  const configPaths = ((): Record<string, string> => {
+    try {
+      const raw = readFileSync(`${configDir}/fapony.config.json`, "utf8");
+      return (JSON.parse(raw)?.paths ?? {}) as Record<string, string>;
+    } catch {
+      return {};
+    }
+  })();
+  const fromConfig = (key: string): string | null =>
+    typeof configPaths[key] === "string"
+      ? join(configDir, configPaths[key])
+      : null;
+
+  planDir = fromConfig("planDir") ?? `${planBase}/plan`;
+
+  // done/ sits beside plan/ (same depth, relative links survive)
+  doneDir =
+    fromConfig("doneDir") ??
+    (!existsSync(`${planBase}/done`) && existsSync(`${planDir}/done`)
+      ? `${planDir}/done`
+      : `${planBase}/done`);
+
+  let emailCache: string | null | undefined;
+  const email = (): string | null =>
+    emailCache !== undefined
+      ? emailCache
+      : (emailCache = gitConfig("user.email", root));
+
+  agent =
+    process.env.MEM_AGENT?.trim() ||
+    usable(process.env.USER) ||
+    usable(email()) ||
+    machineTag();
+
+  // filename = *person*, not client — naming by MEM_AGENT would collide
+  person = slug(
+    usable(gitConfig("user.name", root)) ||
+      usable(process.env.USER) ||
+      usable(email()) ||
+      machineTag(),
+  );
+
+  LOG = `${dir}/log.${person}.jsonl`;
+  memCmd = `fapony mem`;
+}
+
+// --- log file helpers ---
+
+const isLogFile = (f: string): boolean =>
+  f === "log.jsonl" ||
+  (/^log\.[A-Za-z0-9._-]+\.jsonl$/.test(f) &&
+    !/^log\.\d{4}-\d{2}-\d{2}\.jsonl$/.test(f));
+
+const listLogs = (match: (f: string) => boolean): string[] =>
+  existsSync(dir)
+    ? readdirSync(dir)
+        .filter(match)
+        .sort()
+        .map((f) => join(dir, f))
+    : [];
+
+const logFiles = (): string[] => listLogs(isLogFile);
+
+const archivedFiles = (): string[] =>
+  listLogs((f) => /^log\.\d{4}-\d{2}-\d{2}\.jsonl$/.test(f));
+
+// --- core ---
+
+const parseLog = (f: string): LogRow[] =>
+  readFileSync(f, "utf8")
+    .split("\n")
+    .filter(Boolean)
+    .flatMap((l: string, i: number) => {
+      try {
+        return [JSON.parse(l) as LogRow];
+      } catch {
+        console.error(`[mem] skipped ${basename(f)} line ${i + 1} (bad JSON)`);
+        return [];
+      }
+    });
+
+const byTs = (a: LogRow, b: LogRow) => a.ts.localeCompare(b.ts);
+
+// The live view: what `rotate` counts and what open-work commands read. It must
+// stay archive-free or rotate re-imports the rows it just moved out and never
+// gets under its own threshold.
+const rows = (): LogRow[] => logFiles().flatMap(parseLog).sort(byTs);
+
+// The recall view: rotated rows included. A bug closed six months ago is exactly
+// what `find` exists to surface — rotate shrinks the live file, it does not
+// decide what is still worth remembering.
+const allRows = (): LogRow[] =>
+  [...logFiles(), ...archivedFiles()].flatMap(parseLog).sort(byTs);
+
+function put(r: Omit<WorkRow, "ts" | "agent">): void;
+function put(r: Omit<CloseRow, "ts" | "agent">): void;
+function put(r: Omit<ClaimRow, "ts" | "agent">): void;
+function put(r: Omit<ReleaseRow, "ts" | "agent">): void;
+function put(r: Omit<SyncedRow, "ts" | "agent">): void;
+function put(
+  r:
+    | Omit<WorkRow, "ts" | "agent">
+    | Omit<CloseRow, "ts" | "agent">
+    | Omit<ClaimRow, "ts" | "agent">
+    | Omit<ReleaseRow, "ts" | "agent">
+    | Omit<SyncedRow, "ts" | "agent">,
+) {
+  if (blockWrite) throw new Error(blockWrite);
+  mkdirSync(dir, { recursive: true });
+  appendFileSync(
+    LOG,
+    `${JSON.stringify({ ts: new Date().toISOString(), agent, ...r })}\n`,
+  );
+}
+
+function nextId(all: LogRow[]): string {
+  const used = new Set(all.map((r) => ("id" in r ? r.id : "")));
+  let base = Date.now();
+  let id = base.toString(36);
+  while (used.has(id)) {
+    id = base.toString(36) + Math.random().toString(36).slice(2, 4);
+    base++;
+  }
+  return id;
+}
+
+const appendRaw = (path: string, r: LogRow): void =>
+  appendFileSync(path, `${JSON.stringify(r)}\n`);
+
+const rel = (p: string) => relative(root, p) || ".";
+
+const KINDS: WorkKind[] = ["next", "bug", "decision", "note", "hold"];
+
+export type {
+  ClaimRow,
+  CloseRow,
+  LogRow,
+  ReleaseRow,
+  SyncedRow,
+  WorkKind,
+  WorkRow,
+};
+export {
+  agent,
+  allRows,
+  app,
+  appendRaw,
+  dir,
+  doneDir,
+  KINDS,
+  LOG,
+  memCmd,
+  nextId,
+  person,
+  planBase,
+  planDir,
+  put,
+  rel,
+  root,
+  rows,
+};

package/src/memory.ts

@@ -3,37 +3,41 @@
 // ponytail: dedupe close-command logic that was copy-pasted in run.ts + stop.ts
 
 import { execSync } from "node:child_process";
-import { existsSync, readdirSync, readFileSync } from "node:fs";
-import { basename, join } from "node:path";
-import {
-  type Config,
-  DEFAULT_MEMORY_ENTRY,
-  memoryEntry,
-  safetyDeny,
-} from "./db/index.js";
+import { existsSync, readdirSync, readFileSync, realpathSync } from "node:fs";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { type Config, loadConfig, safetyDeny } from "./db/index.js";
 import { assertSafe } from "./safety.js";
 import { templateArgs } from "./util.js";
 
-/** Default memory commands — matches templates/mem/mem.ts CLI. */
+/** Default memory commands — built into fapony via `fapony mem <sub>`. */
 export const DEFAULT_MEMORY: Config["memory"] = {
-  claim: ["bun", DEFAULT_MEMORY_ENTRY, "claim", "{id}"],
-  close: ["bun", DEFAULT_MEMORY_ENTRY, "close", "{id}", "{msg}"],
-  add: ["bun", DEFAULT_MEMORY_ENTRY, "add", "{kind}", "{text}"],
-  kickoff: ["bun", DEFAULT_MEMORY_ENTRY, "kickoff"],
+  claim: ["fapony", "mem", "claim", "{id}"],
+  close: ["fapony", "mem", "close", "{id}", "{msg}"],
+  add: ["fapony", "mem", "add", "{kind}", "{text}"],
+  kickoff: ["fapony", "mem", "kickoff"],
 };
 
 /**
  * Returns the effective memory config:
  * - explicit config.memory wins if set
- * - fallback: config.memory === null + <memoryEntry> exists → DEFAULT_MEMORY
+ * - fallback: a mem log dir exists (any `.fapony/.memory/`) → DEFAULT_MEMORY
  * - otherwise null (no memory)
+ *
+ * Since PLAN-agent-one-call the code is built into fapony (`fapony mem`), so the
+ * old gate on `.fapony/.memory/mem.ts` no longer means anything — that file is
+ * not scaffolded and `init-mem` deletes it. Gate on the dir the writer needs.
  */
 export function resolveMemoryConfig(
   config: Config,
   worktree: string,
 ): Config["memory"] {
   if (config.memory) return config.memory;
-  if (existsSync(join(worktree, memoryEntry(config)))) return DEFAULT_MEMORY;
+  // A real log is not required for wiring: `fapony init` scaffolds an empty
+  // `.fapony/.memory/` and the writer creates the first log there. Resolution
+  // proper (above) still skips empty dirs, so it cannot pick the wrong one.
+  if (resolveMemDir(worktree) || walkUpForMemDir(worktree, true)) {
+    return DEFAULT_MEMORY;
+  }
   return null;
 }
 
@@ -125,36 +129,227 @@ interface RawMemRow {
 }
 
 /**
- * The app's own .fapony/ dir for a worktree root — the same monorepo guess
- * resolveMemDir makes (templates/mem/store.ts is the mirror). Conventions
- * live beside the mem log (SPEC-convention-debt §2.1), so both resolvers must
- * guess identically; the guess is shared here so they cannot drift.
+ * A directory is a mem dir only when it holds a `log.jsonl` or a named
+ * `log.<person>.jsonl` (rotated `log.YYYY-MM-DD.jsonl` archives count too).
+ * A `.fapony/.memory/` scaffolded empty by `fapony init` is not a candidate —
+ * otherwise it would shadow an ancestor that holds the real log (SPEC §1).
  */
-export function resolveAppFaponyDir(worktree: string): string {
-  const app = process.env.MEM_APP ?? basename(worktree).replace(/^wt-/, "");
-  const appBase = ["apps", "packages", "services"]
-    .map((d) => join(worktree, d, app))
-    .find((p) => existsSync(p));
-  return appBase ? join(appBase, ".fapony") : join(worktree, ".fapony");
+function hasMemLogs(dir: string): boolean {
+  try {
+    return readdirSync(dir).some(
+      (f) => f === "log.jsonl" || /^log\.[A-Za-z0-9._-]+\.jsonl$/.test(f),
+    );
+  } catch {
+    return false;
+  }
+}
+
+/** Physical path (symlinks resolved) so start and repo root compare like with
+ *  like; falls back to a lexical resolve when the path does not exist yet. */
+function physical(p: string): string {
+  try {
+    return realpathSync(p);
+  } catch {
+    return resolve(p);
+  }
+}
+
+/** `git rev-parse --show-toplevel` from a directory, or null outside a repo. */
+function gitRootOf(fromDir: string): string | null {
+  try {
+    const root = execSync("git rev-parse --show-toplevel", {
+      cwd: fromDir,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+    }).trim();
+    return root || null;
+  } catch {
+    return null;
+  }
 }
 
 /**
- * Locate the memory dir for a worktree root, mirroring templates/mem/store.ts:
- * in a monorepo the log lives under `<apps|packages|services>/<app>/.fapony/.memory`
- * (app guessed from the dir name, `wt-` prefix stripped; MEM_APP overrides), not
- * at the git root. Single repos fall back to the root-relative layout.
+ * The lexical ancestor of `fromDir` that is the git repo root, or null outside
+ * a repo. `git rev-parse` returns a physical path (it resolves /var → /private/
+ * var on macOS), so the walk compares `physical(dir)` against it and returns the
+ * path in the caller's own lexical form — the returned dir must match what the
+ * caller passed in, not a canonicalized stranger.
  */
-export function resolveMemDir(worktree: string): string | null {
-  const base = resolveAppFaponyDir(worktree);
-
-  const legacyDir = join(base, "..", ".memory");
-  const newDir = join(base, ".memory");
+function repoRootOf(fromDir: string): string | null {
+  const start = resolve(fromDir);
+  const gitRoot = gitRootOf(start);
+  if (!gitRoot) return null;
+  const physicalRoot = physical(gitRoot);
+  let dir = start;
+  while (true) {
+    if (physical(dir) === physicalRoot) return dir;
+    const parent = dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
 
-  if (existsSync(join(legacyDir, "log.jsonl"))) return legacyDir;
-  if (existsSync(newDir)) return newDir;
+/**
+ * Locate the nearest `.fapony/.memory/` by walking up from `fromDir`.
+ *
+ * The walk stops at the git repo root (SPEC §1) — a mem dir in a parent
+ * checkout is never ours. Outside a repo it stops at the filesystem root.
+ * `acceptEmpty` is for the default-wiring check, which only needs the dir the
+ * writer will use (log or not); the resolver itself requires a real log.
+ */
+function walkUpForMemDir(fromDir: string, acceptEmpty: boolean): string | null {
+  const start = resolve(fromDir);
+  const boundary = repoRootOf(start) ?? "/";
+  let dir = start;
+  while (true) {
+    const candidate = join(dir, ".fapony", ".memory");
+    if (existsSync(candidate) && (acceptEmpty || hasMemLogs(candidate))) {
+      return candidate;
+    }
+    if (dir === boundary) break;
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
   return null;
 }
 
+export interface MemDirResult {
+  dir: string | null;
+  step: "flag" | "config" | "walk-up" | "repo-root" | "ambiguous" | "none";
+  /** For step "ambiguous" — the sibling `.fapony/.memory/` dirs that hold logs. */
+  candidates?: string[];
+}
+
+// Dirs that never hold a project mem log and are expensive to walk.
+const SCAN_SKIP = new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  "coverage",
+  "vendor",
+  "out",
+  "target",
+  ".next",
+  ".turbo",
+  ".cache",
+]);
+
+/**
+ * Every `.fapony/.memory/` under `root` that holds a real log, bounded to a
+ * shallow walk. Used only to detect the ambiguous monorepo layout (SPEC §1
+ * fail example): if two or more app-scoped logs exist and nothing at/above cwd
+ * holds one, the caller must refuse rather than start a third log at the root.
+ */
+function findMemDirsUnder(root: string): string[] {
+  const found: string[] = [];
+  const walk = (dir: string, depth: number): void => {
+    if (depth > 5) return;
+    let entries: import("node:fs").Dirent[];
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      if (!e.isDirectory()) continue;
+      if (e.name === ".fapony") {
+        const candidate = join(dir, ".fapony", ".memory");
+        if (hasMemLogs(candidate)) found.push(candidate);
+        continue;
+      }
+      if (e.name.startsWith(".") || SCAN_SKIP.has(e.name)) continue;
+      walk(join(dir, e.name), depth + 1);
+    }
+  };
+  walk(root, 0);
+  return found;
+}
+
+/**
+ * The single resolver: returns the mem dir and which step won.
+ *
+ * Resolution order (SPEC §1):
+ *   1. `--mem-dir <path>` (wins over everything)
+ *   2. `paths.memDir` in the **repo-root** `fapony.config.json` (relative to root)
+ *   3. walk up from cwd for the first `.fapony/.memory/` that holds a real log
+ *   4. `<repo root>/.fapony/.memory/`
+ *
+ * `.memory/` (outside `.fapony/`) and the monorepo app-guess (`wt-<app>`,
+ * `MEM_APP`) are both dead — they are not in the order and never return.
+ */
+function resolveMemDirFrom(
+  fromDir: string,
+  explicitOverride?: string,
+): MemDirResult {
+  // Step 1: --mem-dir flag
+  if (explicitOverride) {
+    return {
+      dir: existsSync(explicitOverride) ? resolve(explicitOverride) : null,
+      step: "flag",
+    };
+  }
+
+  const cwd = resolve(fromDir);
+  const root = repoRootOf(cwd);
+
+  // Step 2: paths.memDir in the repo-root config (FAPONY_CONFIG is not a
+  // path source here — spec §1 pins this to fapony.config.json)
+  const configDir = root ?? cwd;
+  try {
+    const configPath = join(configDir, "fapony.config.json");
+    if (existsSync(configPath)) {
+      const config = loadConfig(configPath);
+      if (config?.paths?.memDir) {
+        const absCfg = isAbsolute(config.paths.memDir)
+          ? config.paths.memDir
+          : join(configDir, config.paths.memDir);
+        if (existsSync(absCfg)) return { dir: absCfg, step: "config" };
+      }
+    }
+  } catch {
+    // no config or unreadable — continue
+  }
+
+  // Step 3: walk up from cwd, only a dir with a real log counts
+  const walked = walkUpForMemDir(cwd, false);
+  if (walked) return { dir: walked, step: "walk-up" };
+
+  // Guard (SPEC §1 fail example): nothing at/above cwd holds a log, but the repo
+  // has two or more app-scoped ones — refuse instead of silently creating a
+  // third log at the root that no app-scoped reader will ever see.
+  if (root) {
+    const candidates = findMemDirsUnder(root);
+    if (candidates.length >= 2) {
+      return { dir: null, step: "ambiguous", candidates };
+    }
+  }
+
+  // Step 4: <repo root>/.fapony/.memory/ — where a new log is created
+  if (root) {
+    const rootDir = join(root, ".fapony", ".memory");
+    if (existsSync(rootDir)) return { dir: rootDir, step: "repo-root" };
+  }
+
+  return { dir: null, step: "none" };
+}
+
+export function resolveMemDir(
+  worktree?: string,
+  explicitOverride?: string,
+): string | null {
+  return resolveMemDirFrom(worktree ?? process.cwd(), explicitOverride).dir;
+}
+
+/** Resolve and report which step won — for `fapony mem where`. */
+export function whereMemDir(
+  fromDir?: string,
+  explicitOverride?: string,
+): MemDirResult {
+  return resolveMemDirFrom(fromDir ?? process.cwd(), explicitOverride);
+}
+
 /**
  * Read every `log*.jsonl` row under the worktree's memory dir, newest first.
  * `sinceIso` (exclusive) drops older rows; omit it to read the whole log.
@@ -168,11 +363,13 @@ export function readMemLog(
   const dir = resolveMemDir(worktree);
   if (!dir) return { rows: [], skipped: 0, filesFound: 0 };
 
-  // read every log*.jsonl (excluding rotated files log.YYYY-MM-DD.jsonl)
+  // Every log*.jsonl, rotated archives (log.YYYY-MM-DD.jsonl) included. They
+  // used to be excluded, which meant the day a repo crossed the rotate
+  // threshold mem_find silently forgot everything already closed — the rows
+  // most worth recalling. Rotate exists to keep the live file small, not to
+  // decide what is still remembered.
   const isLogFile = (f: string): boolean =>
-    f === "log.jsonl" ||
-    (/^log\.[A-Za-z0-9._-]+\.jsonl$/.test(f) &&
-      !/^log\.\d{4}-\d{2}-\d{2}\.jsonl$/.test(f));
+    f === "log.jsonl" || /^log\.[A-Za-z0-9._-]+\.jsonl$/.test(f);
 
   let files: string[];
   try {