fapony 0.1.0

package/templates/mem/mem.ts

@@ -0,0 +1,68 @@
+#!/usr/bin/env bun
+
+// append-only memory log. ห้ามแก้บรรทัดเก่า — ปิดงาน = close (tombstone), git = ประวัติ
+// log อยู่ข้างไฟล์นี้เสมอเมื่อถูกวางโดย `fapony init` (<project>/.fapony/.memory/log.jsonl);
+// สำเนากลางใน monorepo (โค้ดชุดเดียวที่ root) ยังแยก log ราย app: apps/<app>/.fapony/.memory/log.jsonl
+// (repo ที่ยังไม่ย้ายซึ่งมี log เก่าที่ apps/<app>/.memory/log.jsonl จะอ่านที่เดิมต่อ)
+//
+// CLI entry point — all logic lives in:
+//   store.ts       (types + config + rows/put)
+//   selectors.ts   (openRows / claimsOf / staleReport)
+//   render.ts      (fmtRow / fmtClose / printOpenRows / doneLines)
+//   commands/write.ts  (add / close / claim / release / synced / hook)
+//   commands/read.ts   (now / done / stale / find / kickoff)
+//   commands/selftest.ts (test)
+
+import { cmdPlanCheck, cmdPlanSweep } from "./commands/plan.js";
+import {
+  cmdDone,
+  cmdFind,
+  cmdKickoff,
+  cmdNow,
+  cmdStale,
+} from "./commands/read.js";
+import { cmdRotate } from "./commands/rotate.js";
+import { cmdTest } from "./commands/selftest.js";
+import {
+  cmdAdd,
+  cmdClaim,
+  cmdClose,
+  cmdHook,
+  cmdRelease,
+  cmdSynced,
+} from "./commands/write.js";
+
+const [cmd, ...a] = process.argv.slice(2);
+
+if (cmd === "add") {
+  await cmdAdd(a);
+} else if (cmd === "close") {
+  await cmdClose(a);
+} else if (cmd === "claim") {
+  cmdClaim(a);
+} else if (cmd === "release") {
+  await cmdRelease(a);
+} else if (cmd === "synced") {
+  cmdSynced(a);
+} else if (cmd === "hook") {
+  await cmdHook();
+} else if (cmd === "done") {
+  cmdDone();
+} else if (cmd === "stale") {
+  cmdStale();
+} else if (cmd === "find") {
+  cmdFind(a);
+} else if (cmd === "test") {
+  cmdTest();
+} else if (cmd === "kickoff") {
+  cmdKickoff(a);
+} else if (cmd === "plan-sweep") {
+  cmdPlanSweep(a);
+} else if (cmd === "plan-check") {
+  cmdPlanCheck(a);
+} else if (cmd === "rotate") {
+  cmdRotate(a);
+} else {
+  // mem now (default) — next+bug+hold. decision/note ไม่ใช่งานค้าง → ค้นด้วย find แทน
+  cmdNow();
+}

package/templates/mem/render.ts

@@ -0,0 +1,63 @@
+// render.ts — formatting and display helpers for the memory log
+
+import { claimsOf, openRows } from "./selectors.js";
+import type { ClaimRow, CloseRow, LogRow, WorkRow } from "./store.js";
+
+export const fmtRow = (r: WorkRow, claims?: Map<string, ClaimRow>) => {
+  let s = `- [${r.id}]`;
+  if (claims?.has(r.id)) s += ` (${claims.get(r.id)?.agent})`;
+  s += ` ${r.kind} ${r.text}`;
+  if (r.spec) s += ` → ${r.spec}`;
+  return s;
+};
+
+export const printOpenRows = (all: LogRow[], opts?: { showHold?: boolean }) => {
+  const open = openRows(all);
+  const claims = claimsOf(all);
+
+  // in-progress (claimed items)
+  const inProg = open.filter(
+    (r) => claims.has(r.id) && (r.kind === "next" || r.kind === "bug"),
+  );
+  if (inProg.length) {
+    console.log(
+      `\n## in-progress\n${inProg.map((r) => fmtRow(r, claims)).join("\n")}`,
+    );
+  }
+
+  // next (unclaimed only)
+  const nexts = open.filter((r) => r.kind === "next" && !claims.has(r.id));
+  if (nexts.length) {
+    console.log(`\n## next\n${nexts.map((r) => fmtRow(r)).join("\n")}`);
+  }
+
+  // bug (unclaimed only)
+  const bugs = open.filter((r) => r.kind === "bug" && !claims.has(r.id));
+  if (bugs.length) {
+    console.log(`\n## bug\n${bugs.map((r) => fmtRow(r)).join("\n")}`);
+  }
+
+  // hold — sorted by spec for per-plan visibility
+  if (opts?.showHold) {
+    const holds = open
+      .filter((r) => r.kind === "hold")
+      .sort((a, b) => (a.spec ?? "").localeCompare(b.spec ?? ""));
+    if (holds.length) {
+      console.log(`\n## hold\n${holds.map((r) => fmtRow(r)).join("\n")}`);
+    }
+  }
+};
+
+export const fmtClose = (c: CloseRow, byId: Map<string, WorkRow>) => {
+  const o = byId.get(c.ref);
+  const agentStr = c.agent && c.agent !== "unknown" ? ` (${c.agent})` : "";
+  return `- ${c.ts.slice(0, 10)}${agentStr} ${o && "text" in o ? o.text : c.ref} → ${c.text}`;
+};
+
+export const doneLines = (all: LogRow[], limit?: number) => {
+  const workAll = all.filter((r): r is WorkRow => "id" in r);
+  const byId = new Map(workAll.map((r) => [r.id, r] as const));
+  const closes = all.filter((r): r is CloseRow => r.kind === "close").reverse();
+  const slice = limit ? closes.slice(0, limit) : closes;
+  return slice.map((c) => fmtClose(c, byId));
+};

package/templates/mem/selectors.ts

@@ -0,0 +1,144 @@
+// selectors.ts — derive open/claimed/stale views from the append-only log
+
+import type {
+  ClaimRow,
+  CloseRow,
+  LogRow,
+  ReleaseRow,
+  WorkRow,
+} from "./store.js";
+
+// ponytail: reducer = filter + tombstone set. 50k บรรทัด = 9.6MB/26ms — ไฟล์ไม่ใช่คอขวด
+// เพดานจริง = แถวที่ยังเปิดเยอะจน view อ่านไม่รู้เรื่อง → ตอนนั้นค่อย rotate: git mv + append openRows(เก่า) ลงไฟล์ใหม่
+export const openRows = (all: LogRow[]): WorkRow[] => {
+  const dead = new Set(
+    all.filter((r): r is CloseRow => r.kind === "close").map((r) => r.ref),
+  );
+  return all.filter(
+    (r): r is WorkRow =>
+      r.kind !== "close" &&
+      r.kind !== "claim" &&
+      r.kind !== "release" &&
+      r.kind !== "synced" &&
+      "id" in r &&
+      !dead.has(r.id),
+  );
+};
+
+// C) claimsOf: คืน Map ref → latest claim row ที่ยัง active
+// active = แถวล่าสุดของ claim|release เป็น claim และ ref ไม่อยู่ใน dead (close)
+export const claimsOf = (all: LogRow[]): Map<string, ClaimRow> => {
+  const dead = new Set(
+    all.filter((r): r is CloseRow => r.kind === "close").map((r) => r.ref),
+  );
+  const latest = new Map<string, ClaimRow | ReleaseRow>();
+  for (const r of all) {
+    if (r.kind === "claim" || r.kind === "release") {
+      latest.set(r.ref, r);
+    }
+  }
+  const active = new Map<string, ClaimRow>();
+  for (const [ref, r] of latest) {
+    if (r.kind === "claim" && !dead.has(ref)) {
+      active.set(ref, r);
+    }
+  }
+  return active;
+};
+
+// decision ที่ใหม่กว่าทั้ง commit ล่าสุดของ spec และ synced marker = spec ยังไม่ได้อัปเดตตาม
+// + next/hold ที่มี spec ถูกแก้หลังสร้าง = อาจปิดไปแล้วแต่ไม่มีใคร close — เคสจริง: msbnndmt
+// + active claim ที่อายุเกิน 4 ชม. = agent อาจตายกลางงาน
+export const staleReport = (all: LogRow[]): string[] => {
+  const out: string[] = [];
+  const mark: Record<string, number> = {};
+  for (const r of all) {
+    if (r.kind === "synced") mark[r.spec] = Date.parse(r.ts);
+  }
+
+  // batch: collect unique spec paths, spawn one git per path
+  const specPaths = new Set<string>();
+  for (const r of all) {
+    if (r.kind === "decision" && r.spec) specPaths.add(r.spec);
+  }
+  for (const r of openRows(all)) {
+    if ((r.kind === "next" || r.kind === "hold") && r.spec)
+      specPaths.add(r.spec);
+  }
+  const gitDates = new Map<string, number>();
+  for (const spec of specPaths) {
+    // --follow: spec path ที่ถูก git mv (เช่น ย้ายเข้า plan/done/) ยังตามประวัติต่อได้
+    const git = Bun.spawnSync([
+      "git",
+      "log",
+      "-1",
+      "--follow",
+      "--format=%cI",
+      "--",
+      spec,
+    ])
+      .stdout.toString()
+      .trim();
+    if (git) gitDates.set(spec, Date.parse(git));
+  }
+
+  for (const r of all) {
+    if (r.kind === "decision" && r.spec) {
+      const base = Math.max(gitDates.get(r.spec) ?? 0, mark[r.spec] ?? 0);
+      if (base < Date.parse(r.ts))
+        out.push(
+          `STALE ${r.spec}: decision ${r.ts.slice(0, 10)} never made it into the spec — "${r.text}"`,
+        );
+    }
+  }
+  for (const r of openRows(all)) {
+    if ((r.kind === "next" || r.kind === "hold") && r.spec) {
+      const gitDate = gitDates.get(r.spec);
+      // ponytail: grace 24 ชม. — "log next แล้วเขียน/commit plan ต่อในวันเดียวกัน" คือ workflow ปกติ
+      // ไม่ใช่สัญญาณว่างานจบแล้วลืมปิด (เคสจริงที่ต้องจับอย่าง msbnndmt ห่างกันเป็นวัน) —
+      // ไม่มี grace = SUSPECT ขึ้นทุกแผนที่เพิ่งเขียน แล้วทุกคนเรียนรู้ที่จะเลื่อนผ่าน stale ทั้งบล็อก
+      if (gitDate && gitDate > Date.parse(r.ts) + 86_400_000)
+        out.push(
+          `SUSPECT [${r.id}] ${r.spec} changed after this ${r.kind} (${r.ts.slice(0, 10)}) — check whether it is already done`,
+        );
+    }
+  }
+  const claims = claimsOf(all);
+  for (const [ref, c] of claims) {
+    const ageH = (Date.now() - Date.parse(c.ts)) / 3_600_000;
+    if (ageH > 4) {
+      out.push(
+        `SUSPECT claim [${ref}] by ${c.agent} ${c.ts.slice(0, 10)} never closed/released — the agent may have died mid-task`,
+      );
+    }
+  }
+  return out;
+};
+
+// rotate: แถวที่ต้องแบกต่อในไฟล์ log ใหม่หลัง archive
+// - next/bug/hold ที่ยังเปิด + claim ที่ยัง active อยู่บนแถวนั้น (close/claim ของ ref ที่ปิดแล้ว = ทิ้งได้)
+// - decision/note ยังไม่มี "close" ของตัวเอง (ประวัติถาวรตามดีไซน์) แต่ resolved ได้ทางอ้อมผ่าน synced:
+//   spec ถูก synced *หลัง* แถวนี้แล้ว = ข้อมูลเข้า spec แล้วจริง เก็บใน archive (git) พอ ไม่ต้องแบกในไฟล์ hot
+//   (logic เดียวกับ staleReport's decision check — ไม่มี spec หรือยังไม่ synced ทันแถวนี้ = ยังถือว่า relevant, เก็บไว้)
+// ponytail: decision/note ที่ไม่มี spec ไม่มีทางรู้ว่า resolved แล้วหรือยัง — เก็บไว้ตลอด (เพดานจริงคือ
+// ต้อง attach spec ตั้งแต่ log ถ้าอยากให้ rotate ออกได้ในอนาคต ไม่ใช่ปัญหาของ rotate เอง)
+export const rotateKeep = (all: LogRow[]): LogRow[] => {
+  const open = openRows(all);
+  const workOpen = open.filter(
+    (r) => r.kind === "next" || r.kind === "bug" || r.kind === "hold",
+  );
+  const claims = claimsOf(all);
+  const openIds = new Set(workOpen.map((r) => r.id));
+  const keepClaims = [...claims.values()].filter((c) => openIds.has(c.ref));
+
+  const syncedAt: Record<string, number> = {};
+  for (const r of all)
+    if (r.kind === "synced") syncedAt[r.spec] = Date.parse(r.ts);
+  const keepDecisionNote = open.filter(
+    (r) =>
+      (r.kind === "decision" || r.kind === "note") &&
+      (!r.spec || !(r.spec in syncedAt) || syncedAt[r.spec] < Date.parse(r.ts)),
+  );
+
+  return [...workOpen, ...keepDecisionNote, ...keepClaims];
+};

package/templates/mem/store.ts

@@ -0,0 +1,285 @@
+// store.ts — types + config + read/write primitives for the append-only memory log
+
+import {
+  appendFileSync,
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+} from "node:fs";
+import { basename, dirname, join, relative } from "node:path";
+
+// --- 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;
+
+// --- config ---
+
+const root = Bun.spawnSync(["git", "rev-parse", "--show-toplevel"])
+  .stdout.toString()
+  .trim();
+// ponytail: worktree ชื่อ wt-<app> = monorepo scope (apps/<app>/.fapony/.memory).
+// fapony template: repo เดี่ยว (ไม่มี apps/) → fallback ไป .fapony/.memory ที่ root ตรงๆ
+// ไม่ต้อง config/flag ทั้งสองแบบ
+const app = process.env.MEM_APP ?? basename(root).replace(/^wt-/, "");
+// โฟลเดอร์รวม app หาจาก {apps,packages,services}/<app> ตัวแรกที่มีจริง — ลำดับคงที่
+// apps → packages → services ตัวแรกที่เจอชนะ (ลำดับคือสัญญา ไม่ใช่บังเอิญ)
+// guard `unknown app` ข้างล่างยังผูกกับ apps/ เหมือนเดิม — ไม่ขยายในรอบนี้
+const appBase: string | undefined = ["apps", "packages", "services"]
+  .map((d) => `${root}/${d}/${app}`)
+  .find((p) => existsSync(p));
+const monorepo = appBase !== undefined;
+
+// สำเนาที่ `fapony init` วางไว้ อยู่ใน <project>/.fapony/.memory/ — log กับ plan ของมัน
+// ต้องอิงโฟลเดอร์ตัวเอง ไม่ใช่ git root: เคสที่พังจริงคือ apps/<x>/.fapony/.memory/ ใน monorepo
+// ซึ่ง heuristic ด้านล่างจะชี้ไป apps/<ชื่อ worktree>/.fapony/.memory = เขียน log ปนโปรเจกต์อื่น
+// แต่สำเนากลางที่ย้ายเข้า .fapony/.memory ที่ root ของ monorepo เอง (โค้ดชุดเดียว, log แยกราย
+// app — เช่น vela) ต้อง "ไม่" ถือเป็น scaffolded แม้ path จะแมตช์เหมือนกัน เพราะยังต้องเดา app
+// จาก monorepo อยู่ — ตัวแยกคือ "เดา app ได้ไหม" (`monorepo`) ไม่ใช่ "มีโฟลเดอร์รวม app ไหม":
+// แค่มี apps/ อยู่ที่ root ไม่ได้แปลว่าสำเนานี้เป็นสำเนากลาง — `fapony init <monorepo root>` ก็วาง
+// .fapony/.memory ที่ root เหมือนกัน แล้วมันต้องอิงโฟลเดอร์ตัวเอง ไม่งั้นตายที่ guard ข้างล่าง
+// ตั้งแต่คำสั่งแรกทั้งที่ plan ของมันอยู่ข้าง ๆ นั่นเอง
+const centralAtMonorepoRoot =
+  import.meta.dir === `${root}/.fapony/.memory` && monorepo;
+const scaffolded =
+  import.meta.dir.includes("/.fapony/.memory") && !centralAtMonorepoRoot;
+
+// มี apps/ แต่ไม่มี apps/<app> = เดา app ผิด (worktree ชื่อไม่ตรง / typo ใน MEM_APP) — ตายตรงนี้
+// ดีกว่า fallback เงียบ ๆ ไปเขียน log ที่ root ซึ่งจะกลายเป็น log กำพร้าที่ไม่มีใครอ่าน
+// (สำเนาที่ scaffold ไว้ใต้ apps/<x>/.fapony/.memory/ อิงโฟลเดอร์ตัวเอง ไม่ต้องเดา จึงไม่เข้าเงื่อนไขนี้)
+if (!scaffolded && !monorepo && existsSync(`${root}/apps`)) {
+  console.error(
+    `unknown app (guessed "${app}" from ${basename(root)}) — pass MEM_APP=<app>`,
+  );
+  process.exit(1);
+}
+// default ใหม่: log อยู่ใต้ .fapony/.memory — fallback ไป .memory/ เดิมเมื่อมี log เก่าอยู่จริง
+// เช็ค log.jsonl ไม่ใช่ dir: โฟลเดอร์ว่างที่ใครเผลอ mkdir ทิ้งไว้ต้องไม่ล็อก repo ไว้กับ layout เก่า
+const newDir = appBase
+  ? `${appBase}/.fapony/.memory`
+  : `${root}/.fapony/.memory`;
+const legacyDir = appBase ? `${appBase}/.memory` : `${root}/.memory`;
+const dir = scaffolded
+  ? import.meta.dir
+  : existsSync(`${legacyDir}/log.jsonl`)
+    ? legacyDir
+    : newDir;
+// ใครเขียนแถวนี้ — client ตั้ง MEM_AGENT ทับได้ ("claude-code", "opencode")
+const agent = process.env.MEM_AGENT || process.env.USER || "unknown";
+
+// ชื่อไฟล์ = *คน* ไม่ใช่ client ตั้งใจให้ต่างจาก agent ข้างบน: ถ้าใช้ MEM_AGENT ตั้งชื่อไฟล์
+// สองคนที่เปิด Claude Code จะกลับไปเขียน log.claude-code.jsonl ใบเดียวกัน = ชนเหมือนเดิม
+// git user.name มีอยู่แล้วทุกเครื่องที่ commit ได้ จึงไม่ต้องตั้ง env และไม่ต้องเพิ่ม config
+const person = (
+  Bun.spawnSync(["git", "config", "user.name"]).stdout.toString().trim() ||
+  process.env.USER ||
+  "unknown"
+)
+  .toLowerCase()
+  .replace(/[^a-z0-9._-]+/g, "-")
+  .replace(/^-+|-+$/g, "");
+
+// เขียนไฟล์ของตัวเอง อ่านของทุกคน — สองคนไม่เคยแตะไฟล์เดียวกัน = merge conflict
+// เป็นศูนย์โดยโครงสร้าง ไม่ต้องพึ่ง merge=union หรือให้ GitHub ทำตัวดีตอน merge PR
+const LOG = `${dir}/log.${person || "unknown"}.jsonl`;
+
+// log.jsonl = ของเดิมก่อนแยกไฟล์ (ยังอ่านตลอดไป ไม่ต้อง migrate)
+// ข้าม log.YYYY-MM-DD.jsonl ที่ rotate สร้าง ไม่งั้น rotate จะไม่ลดอะไรเลยเพราะอ่านกลับเข้ามา
+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 logFiles = (): string[] =>
+  existsSync(dir)
+    ? readdirSync(dir)
+        .filter(isLogFile)
+        .sort()
+        .map((f) => join(dir, f))
+    : [];
+
+// โฟลเดอร์ที่ plan/ กับ done/ ของโปรเจกต์นี้อยู่ใต้มัน — จุดเดียวที่ประกอบ path เหล่านี้
+// (ก่อนหน้านี้ commands/plan.ts hardcode `apps/<app>/plan` 10 จุด = ตายสนิทกับ repo เดี่ยว)
+const planBase = scaffolded
+  ? dirname(import.meta.dir) // <project>/.fapony
+  : (appBase ?? root);
+
+// fapony.config.json คือ *ข้อตกลง* ว่า plan อยู่ไหน ส่วน planBase ข้างบนเป็นแค่การเดา —
+// มีไฟล์เมื่อไหร่ต้องชนะการเดาเสมอ (vela ประกาศ `apps/vela/plan` ไว้ตรง ๆ บังเอิญตรงกับที่เดาได้
+// แต่ repo ที่วาง plan ไว้ที่อื่นจะพังเงียบ ๆ ถ้าไม่อ่าน)
+// อ่านที่ระดับโปรเจกต์เท่านั้น: สำเนาที่ scaffold ใน apps/<x>/.fapony/ ต้องไม่หยิบ config ของ
+// monorepo ที่ root มาใช้ เพราะนั่นเป็น path ของอีกโปรเจกต์หนึ่ง
+const configDir = scaffolded ? dirname(planBase) : root;
+
+const configPaths = ((): Record<string, string> => {
+  try {
+    const raw = readFileSync(`${configDir}/fapony.config.json`, "utf8");
+    return (JSON.parse(raw)?.paths ?? {}) as Record<string, string>;
+  } catch {
+    // ไม่มีไฟล์ / JSON เสีย → ใช้ค่าที่เดาได้ ไม่ใช่ error: memory ต้องทำงานได้โดยไม่มี fapony
+    return {};
+  }
+})();
+
+const fromConfig = (key: string): string | null =>
+  typeof configPaths[key] === "string"
+    ? join(configDir, configPaths[key])
+    : null;
+
+// app ที่ย้าย plan เข้า .fapony/ แล้วให้ใช้ของใหม่ ที่ยังไม่ย้ายใช้ของเดิม — โมโนเรโปจึงย้ายทีละ app ได้
+// โดยไม่ต้องแตะ config (config มี planDir ค่าเดียว ประกาศเมื่อไหร่ app อื่นก็ชี้ผิดตามไปด้วย)
+const base = existsSync(`${planBase}/.fapony`)
+  ? `${planBase}/.fapony`
+  : planBase;
+
+const planDir = fromConfig("planDir") ?? `${base}/plan`;
+
+// done/ อยู่ข้าง plan/ (ย้ายแล้วลึกเท่าเดิม ลิงก์ relative ในไฟล์รอด) — repo ที่ยัง layout เก่า
+// เก็บ plan/done/ ไว้ ก็ใช้ของเดิมต่อ ไม่ต้องย้ายก่อนถึงจะ sweep ได้
+const doneDir =
+  fromConfig("doneDir") ??
+  (!existsSync(`${base}/done`) && existsSync(`${planDir}/done`)
+    ? `${planDir}/done`
+    : `${base}/done`);
+
+// path ที่เอาไว้โชว์/บันทึกลง log — อิง repo root เสมอ (`apps/vela/plan`, `.fapony/plan`)
+const rel = (p: string) => relative(root, p) || ".";
+
+// คำสั่งที่บอกให้ผู้ใช้พิมพ์ ต้องเป็น path ของ mem.ts ตัวที่กำลังรันอยู่จริง ไม่ใช่ค่าคงที่ —
+// สำเนาที่ `fapony init` วางไว้อยู่ที่ .fapony/.memory/ ไม่ใช่ .memory/ ที่ help text เดิม hardcode
+const memCmd = `bun ${rel(dir)}/mem.ts`;
+
+const KINDS: WorkKind[] = ["next", "bug", "decision", "note", "hold"];
+
+// --- core ---
+
+const rows = (): LogRow[] =>
+  logFiles()
+    .flatMap((f) =>
+      readFileSync(f, "utf8")
+        .split("\n")
+        .filter(Boolean)
+        .flatMap((l: string, i: number) => {
+          try {
+            return [JSON.parse(l) as LogRow];
+          } catch {
+            // ponytail: 1 บรรทัดพัง (escape เสีย) ไม่ควรทำให้ทั้ง log อ่านไม่ได้ — ข้ามแล้วเตือน
+            console.error(
+              `[mem] skipped ${basename(f)} line ${i + 1} (bad JSON)`,
+            );
+            return [];
+          }
+        }),
+    )
+    // หลายไฟล์ต่อกันแล้วลำดับเวลาสลับ — ทุก selector อ่านจากบนลงล่างโดยถือว่าเรียงตาม ts
+    .sort((a, b) => a.ts.localeCompare(b.ts));
+
+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">,
+) {
+  mkdirSync(dir, { recursive: true });
+  appendFileSync(
+    LOG,
+    `${JSON.stringify({ ts: new Date().toISOString(), agent, ...r })}\n`,
+  );
+}
+
+// ponytail: กัน id ชน — base36 + increment ต่อ retry + random suffix
+// ใช้ร่วมกันทุกที่ที่ต้อง generate WorkRow.id (cmdAdd, ship-log ใน cmdPlanSweep)
+// ห้าม copy loop นี้ไปวางที่ใหม่ — แก้ scheme ที่นี่ที่เดียว
+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;
+}
+
+// เขียนแถวดิบ (ts/agent เดิม ไม่ generate ใหม่) — ใช้ตอน rotate ย้าย row เก่าไปไฟล์ใหม่
+// ปกติเขียน log ต้องผ่าน put() เท่านั้น อันนี้ทางเดียวที่ยกเว้น
+const appendRaw = (path: string, r: LogRow): void =>
+  appendFileSync(path, `${JSON.stringify(r)}\n`);
+
+export type {
+  ClaimRow,
+  CloseRow,
+  LogRow,
+  ReleaseRow,
+  SyncedRow,
+  WorkKind,
+  WorkRow,
+};
+export {
+  agent,
+  app,
+  appendRaw,
+  configDir,
+  dir,
+  doneDir,
+  KINDS,
+  LOG,
+  memCmd,
+  nextId,
+  person,
+  planBase,
+  planDir,
+  put,
+  rel,
+  root,
+  rows,
+};