@remnic/core 9.66.0 → 9.66.2

package/src/activity/timeline/journal-recap.ts

@@ -0,0 +1,130 @@
+/**
+ * Deterministic daily journal recap from timeline cards (issue #2051).
+ *
+ * Pure: cards + date + timezone in, Markdown out. No LLM, no I/O.
+ * Same cards always produce the same bytes. Empty days still yield a
+ * valid file body. Does not invent people, mood, or productivity claims.
+ */
+import { activityDayWindow } from "../digest.js";
+import type { TimelineCard } from "./types.js";
+
+export interface DeterministicJournalOptions {
+  date: string;
+  timezone: string;
+}
+
+interface ClippedCard {
+  card: TimelineCard;
+  startMs: number;
+  endMs: number;
+  durationMs: number;
+}
+
+function formatMinutes(ms: number): string {
+  return `${Math.round(ms / 60_000)}m`;
+}
+
+function clipToWindow(
+  cards: readonly TimelineCard[],
+  winStart: number,
+  winEnd: number,
+): ClippedCard[] {
+  const clipped: ClippedCard[] = [];
+  for (const card of cards) {
+    const start = Date.parse(card.startUtc);
+    const end = Date.parse(card.endUtc);
+    if (!Number.isFinite(start) || !Number.isFinite(end)) continue;
+    const startMs = Math.max(start, winStart);
+    const endMs = Math.min(end, winEnd);
+    if (endMs <= startMs) continue;
+    clipped.push({ card, startMs, endMs, durationMs: endMs - startMs });
+  }
+  clipped.sort((left, right) => {
+    const byStart = left.startMs - right.startMs;
+    if (byStart !== 0) return byStart;
+    const byTitle = left.card.title.localeCompare(right.card.title);
+    if (byTitle !== 0) return byTitle;
+    return left.card.id.localeCompare(right.card.id);
+  });
+  return clipped;
+}
+
+function categoryLines(clipped: readonly ClippedCard[]): string[] {
+  const totals = new Map<string, number>();
+  for (const row of clipped) {
+    totals.set(row.card.categoryId, (totals.get(row.card.categoryId) ?? 0) + row.durationMs);
+  }
+  const rows = [...totals.entries()].sort((left, right) => {
+    const byDuration = right[1] - left[1];
+    return byDuration !== 0 ? byDuration : left[0].localeCompare(right[0]);
+  });
+  if (rows.length === 0) return ["_No categories._"];
+  return rows.map(([categoryId, durationMs]) => `- ${formatMinutes(durationMs)} ${categoryId}`);
+}
+
+function mergeIntervals(intervals: readonly (readonly [number, number])[]): Array<[number, number]> {
+  const ordered = [...intervals].sort((left, right) => left[0] - right[0] || left[1] - right[1]);
+  const merged: Array<[number, number]> = [];
+  for (const [start, end] of ordered) {
+    const last = merged[merged.length - 1];
+    if (!last || start > last[1]) merged.push([start, end]);
+    else last[1] = Math.max(last[1], end);
+  }
+  return merged;
+}
+
+function countGaps(
+  winStart: number,
+  winEnd: number,
+  intervals: readonly (readonly [number, number])[],
+): number {
+  const merged = mergeIntervals(intervals);
+  let gaps = 0;
+  let cursor = winStart;
+  for (const [start, end] of merged) {
+    if (start > cursor) gaps += 1;
+    cursor = Math.max(cursor, end);
+  }
+  if (cursor < winEnd) gaps += 1;
+  return gaps;
+}
+
+/** Render a byte-stable Markdown journal for one local day. */
+export function renderDeterministicJournal(
+  cards: readonly TimelineCard[],
+  options: DeterministicJournalOptions,
+): string {
+  const window = activityDayWindow(options.date, options.timezone);
+  const winStart = Date.parse(window.startUtc);
+  const winEnd = Date.parse(window.endUtc);
+  const clipped = clipToWindow(cards, winStart, winEnd);
+  const idle = clipped.filter((row) => row.card.kind === "idle").length;
+  const pause = clipped.filter((row) => row.card.kind === "pause").length;
+  const gaps = countGaps(
+    winStart,
+    winEnd,
+    clipped.map((row) => [row.startMs, row.endMs]),
+  );
+  const cardLines =
+    clipped.length === 0
+      ? ["_No cards._"]
+      : clipped.map((row) => `- ${formatMinutes(row.durationMs)} ${row.card.title}`);
+  return [
+    `# Journal — ${options.date} (${options.timezone})`,
+    "",
+    "## Categories",
+    "",
+    ...categoryLines(clipped),
+    "",
+    "## Cards",
+    "",
+    ...cardLines,
+    "",
+    "## Gaps / idle / pause",
+    "",
+    `- Gaps: ${gaps}`,
+    `- Idle: ${idle}`,
+    `- Pause: ${pause}`,
+    "",
+  ].join("\n");
+}

package/src/activity/timeline/query.test.ts

@@ -0,0 +1,198 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { parseActivityConfig } from "../config.js";
+import {
+  queryTimelineRange,
+  queryTimelineSearch,
+  runTimelineCliCommand,
+  type TimelineQueryCard,
+} from "./query.js";
+import type { TimelineCard } from "./types.js";
+
+function card(overrides: Partial<TimelineQueryCard> & Pick<TimelineCard, "id" | "startUtc" | "endUtc">): TimelineQueryCard {
+  return {
+    kind: "activity",
+    title: "Untitled",
+    summary: "none",
+    categoryId: "development",
+    confidence: 1,
+    dayKey: overrides.startUtc.slice(0, 10),
+    timezone: "UTC",
+    machine: "ws-a",
+    evidenceIds: [],
+    evidenceRange: null,
+    ...overrides,
+  };
+}
+
+const BOUNDARY_A = card({
+  id: "a",
+  title: "Morning editor",
+  summary: "typed in vscode",
+  startUtc: "2026-07-10T10:00:00.000Z",
+  endUtc: "2026-07-10T11:00:00.000Z",
+});
+const BOUNDARY_B = card({
+  id: "b",
+  title: "Standup call",
+  summary: "zoom standup",
+  categoryId: "communication",
+  startUtc: "2026-07-10T11:00:00.000Z",
+  endUtc: "2026-07-10T12:00:00.000Z",
+});
+const LATER = card({
+  id: "c",
+  title: "Docs writeup",
+  summary: "edited the standup notes",
+  detailedSummary: "longer writeup about the morning editor session",
+  startUtc: "2026-07-11T09:00:00.000Z",
+  endUtc: "2026-07-11T10:00:00.000Z",
+});
+const DISTRACTION = card({
+  id: "d",
+  title: "Video break",
+  summary: "watched a clip",
+  categoryId: "entertainment",
+  distraction: true,
+  startUtc: "2026-07-10T12:00:00.000Z",
+  endUtc: "2026-07-10T12:30:00.000Z",
+});
+
+const CARDS = [BOUNDARY_A, BOUNDARY_B, LATER, DISTRACTION];
+
+test("range at a boundary instant returns only the containing card", () => {
+  const instant = "2026-07-10T11:00:00.000Z";
+  const result = queryTimelineRange(CARDS, { from: instant, to: instant, format: "cards" });
+  assert.ok(Array.isArray(result));
+  assert.deepEqual(
+    result.map((item) => item.id),
+    ["b"],
+  );
+});
+
+test("range rejects a reversed window and names the limit", () => {
+  assert.throws(
+    () =>
+      queryTimelineRange(CARDS, {
+        from: "2026-07-11T00:00:00.000Z",
+        to: "2026-07-10T00:00:00.000Z",
+        format: "cards",
+      }),
+    /reversed range/,
+  );
+});
+
+test("range rejects a 400-day window and names maxRangeDays", () => {
+  assert.throws(
+    () =>
+      queryTimelineRange(CARDS, {
+        from: "2026-01-01T00:00:00.000Z",
+        to: "2027-02-05T00:00:00.000Z",
+        format: "cards",
+      }),
+    /maxRangeDays \(31\)/,
+  );
+});
+
+test("range format cards and compact both round-trip the fixture", () => {
+  const from = "2026-07-10T10:00:00.000Z";
+  const to = "2026-07-10T12:00:00.000Z";
+  const full = queryTimelineRange(CARDS, { from, to, format: "cards", includeDistractions: true });
+  assert.ok(Array.isArray(full));
+  assert.deepEqual(
+    full.map((item) => item.id),
+    ["a", "b"],
+  );
+  const compact = queryTimelineRange(CARDS, { from, to, format: "compact", includeDistractions: true });
+  assert.ok(!Array.isArray(compact));
+  assert.equal(compact.day, "2026-07-10");
+  assert.deepEqual(compact.cards, [
+    { start: BOUNDARY_A.startUtc, end: BOUNDARY_A.endUtc, category: "development", title: "Morning editor", summary: "typed in vscode" },
+    { start: BOUNDARY_B.startUtc, end: BOUNDARY_B.endUtc, category: "communication", title: "Standup call", summary: "zoom standup" },
+  ]);
+});
+
+test("range rejects an unknown format against the allow-list", () => {
+  assert.throws(
+    () =>
+      queryTimelineRange(CARDS, {
+        from: "2026-07-10T10:00:00.000Z",
+        to: "2026-07-10T11:00:00.000Z",
+        format: "markdown" as "cards",
+      }),
+    /format must be one of: cards, compact/,
+  );
+});
+
+test("search empty results stay ok and unreadable store is distinct", () => {
+  assert.deepEqual(queryTimelineSearch(CARDS, { query: "no-such-token" }), { ok: true, results: [] });
+  assert.deepEqual(queryTimelineSearch(null, { query: "editor" }), { ok: false, error: "store_unreadable" });
+  assert.deepEqual(queryTimelineSearch(undefined, { query: "editor" }), { ok: false, error: "store_unreadable" });
+});
+
+test("search rank is match count then recency then id", () => {
+  const shuffled = [LATER, DISTRACTION, BOUNDARY_B, BOUNDARY_A];
+  const found = queryTimelineSearch(shuffled, { query: "standup editor" });
+  assert.equal(found.ok, true);
+  if (!found.ok) return;
+  assert.deepEqual(
+    found.results.map((item) => item.id),
+    ["c", "b", "a"],
+  );
+});
+
+test("search honors detailedSummary and a 1..50 limit", () => {
+  const found = queryTimelineSearch(CARDS, { query: "writeup", limit: 1 });
+  assert.equal(found.ok, true);
+  if (!found.ok) return;
+  assert.deepEqual(
+    found.results.map((item) => item.id),
+    ["c"],
+  );
+  assert.throws(() => queryTimelineSearch(CARDS, { query: "editor", limit: 0 }), /limit must be an integer from 1 to 50/);
+  assert.throws(() => queryTimelineSearch(CARDS, { query: "editor", limit: 51 }), /limit must be an integer from 1 to 50/);
+});
+
+test("timeline.qa defaults off and honors 0-style disable plus maxRangeDays bounds", () => {
+  const defaults = parseActivityConfig(undefined).timeline.qa;
+  assert.deepEqual(defaults, { enabled: false, maxRangeDays: 31 });
+  assert.equal(parseActivityConfig({ timeline: { qa: { enabled: 0 } } }).timeline.qa.enabled, false);
+  assert.equal(parseActivityConfig({ timeline: { qa: { enabled: "off" } } }).timeline.qa.enabled, false);
+  assert.equal(parseActivityConfig({ timeline: { qa: { enabled: true, maxRangeDays: 1 } } }).timeline.qa.maxRangeDays, 1);
+  assert.throws(
+    () => parseActivityConfig({ timeline: { qa: { maxRangeDays: 0 } } }),
+    /maxRangeDays must be an integer from 1 to 366/,
+  );
+  assert.throws(
+    () => parseActivityConfig({ timeline: { qa: { maxRangeDays: 367 } } }),
+    /maxRangeDays must be an integer from 1 to 366/,
+  );
+});
+
+test("CLI runner accepts in-memory cards and does not need a store", async () => {
+  const qa = { enabled: true, maxRangeDays: 31 };
+  let out = "";
+  let err = "";
+  const io = {
+    stdout: { write: (chunk: string) => (out += chunk) },
+    stderr: { write: (chunk: string) => (err += chunk) },
+  };
+  const rangeCode = await runTimelineCliCommand(
+    { cards: CARDS, qa, timelineEnabled: true },
+    ["range", "--from", "2026-07-10T11:00:00.000Z", "--to", "2026-07-10T11:00:00.000Z", "--format", "cards"],
+    io,
+  );
+  assert.equal(rangeCode, 0);
+  assert.deepEqual(JSON.parse(out).map((item: TimelineCard) => item.id), ["b"]);
+
+  out = "";
+  const unread = await runTimelineCliCommand(
+    { cards: null, qa, timelineEnabled: true },
+    ["search", "--query", "editor"],
+    io,
+  );
+  assert.equal(unread, 1);
+  assert.deepEqual(JSON.parse(out), { ok: false, error: "store_unreadable" });
+  assert.equal(err, "");
+});

package/src/activity/timeline/query.ts

@@ -0,0 +1,313 @@
+/**
+ * Timeline range/search query (issue #1983 PR1).
+ *
+ * Pure functions over an in-memory card list. Half-open UTC [from, to).
+ * A zero-length range is an instant: include the card whose [start, end)
+ * contains it. Search returns distinct empty vs store_unreadable shapes.
+ *
+ * Config: activity.timeline.qa.{enabled, maxRangeDays}.
+ * MCP/HTTP and recall injection are later PRs.
+ */
+import { parseFlexibleIsoTimestamp } from "../../utils/iso-timestamp.js";
+import type { ActivityTimelineQaConfig } from "../types.js";
+import type { TimelineCard } from "./types.js";
+
+const RANGE_FORMATS = ["cards", "compact"] as const;
+const MS_PER_DAY = 86_400_000;
+const DEFAULT_MAX_RANGE_DAYS = 31;
+const DEFAULT_SEARCH_LIMIT = 10;
+const MIN_SEARCH_LIMIT = 1;
+const MAX_SEARCH_LIMIT = 50;
+
+export type TimelineRangeFormat = (typeof RANGE_FORMATS)[number];
+
+/** Card fields the query layer reads; later slices may add optional extras. */
+export type TimelineQueryCard = TimelineCard & {
+  detailedSummary?: string;
+  distraction?: boolean;
+};
+
+export interface TimelineRangeQuery {
+  from: string;
+  to: string;
+  categories?: readonly string[];
+  includeDistractions?: boolean;
+  format: TimelineRangeFormat;
+  maxRangeDays?: number;
+}
+
+export interface TimelineCompactCard {
+  start: string;
+  end: string;
+  category: string;
+  title: string;
+  summary: string;
+}
+
+export interface TimelineCompactRange {
+  day: string;
+  cards: TimelineCompactCard[];
+}
+
+export interface TimelineSearchQuery {
+  query: string;
+  from?: string;
+  to?: string;
+  limit?: number;
+}
+
+export type TimelineSearchResult =
+  | { ok: true; results: TimelineQueryCard[] }
+  | { ok: false; error: "store_unreadable" };
+
+export interface TimelineCliIo {
+  stdout: { write(chunk: string): unknown };
+  stderr: { write(chunk: string): unknown };
+}
+
+/** Inject cards so CLI tests never need ActivityStore. */
+export interface TimelineCliDeps {
+  cards: readonly TimelineQueryCard[] | null;
+  qa: ActivityTimelineQaConfig;
+  timelineEnabled?: boolean;
+}
+
+const USAGE = `Usage: timeline <command> [options]
+
+Commands:
+  range --from <ISO> --to <ISO> [--format cards|compact] [--categories id,id] [--include-distractions]
+  search --query <text> [--from <ISO>] [--to <ISO>] [--limit N]
+`;
+
+const VALUE_FLAGS: Record<string, true> = {
+  "--from": true,
+  "--to": true,
+  "--format": true,
+  "--categories": true,
+  "--query": true,
+  "--limit": true,
+};
+const BOOLEAN_FLAGS: Record<string, true> = { "--include-distractions": true };
+
+function parseInstant(value: string, label: string): number {
+  const ms = parseFlexibleIsoTimestamp(value);
+  if (ms === null) {
+    throw new TypeError(`${label} must be an ISO date or datetime`);
+  }
+  return ms;
+}
+
+function assertRange(fromMs: number, toMs: number, maxRangeDays: number): void {
+  if (fromMs > toMs) {
+    throw new RangeError("reversed range: from must be <= to");
+  }
+  if (fromMs === toMs) return;
+  if (toMs - fromMs > maxRangeDays * MS_PER_DAY) {
+    throw new RangeError(`range exceeds timeline.qa.maxRangeDays (${maxRangeDays})`);
+  }
+}
+
+function cardOverlaps(card: TimelineQueryCard, fromMs: number, toMs: number): boolean {
+  const start = Date.parse(card.startUtc);
+  const end = Date.parse(card.endUtc);
+  if (fromMs === toMs) return start <= fromMs && fromMs < end;
+  return start < toMs && end > fromMs;
+}
+
+function passesFilters(
+  card: TimelineQueryCard,
+  categories: ReadonlySet<string> | undefined,
+  includeDistractions: boolean,
+): boolean {
+  if (!includeDistractions && card.distraction === true) return false;
+  if (categories && !categories.has(card.categoryId)) return false;
+  return true;
+}
+
+function filterRange(
+  cards: readonly TimelineQueryCard[],
+  fromMs: number,
+  toMs: number,
+  categories: ReadonlySet<string> | undefined,
+  includeDistractions: boolean,
+): TimelineQueryCard[] {
+  return cards.filter(
+    (card) => cardOverlaps(card, fromMs, toMs) && passesFilters(card, categories, includeDistractions),
+  );
+}
+
+function toCompact(cards: readonly TimelineQueryCard[], from: string): TimelineCompactRange {
+  const day = from.length >= 10 ? from.slice(0, 10) : cards[0]?.dayKey ?? from;
+  return {
+    day,
+    cards: cards.map((card) => ({
+      start: card.startUtc,
+      end: card.endUtc,
+      category: card.categoryId,
+      title: card.title,
+      summary: card.summary,
+    })),
+  };
+}
+
+export function queryTimelineRange(
+  cards: readonly TimelineQueryCard[],
+  query: TimelineRangeQuery,
+): TimelineCard[] | TimelineCompactRange {
+  if (!RANGE_FORMATS.includes(query.format)) {
+    throw new TypeError(`format must be one of: ${RANGE_FORMATS.join(", ")}`);
+  }
+  const maxRangeDays = query.maxRangeDays ?? DEFAULT_MAX_RANGE_DAYS;
+  const fromMs = parseInstant(query.from, "from");
+  const toMs = parseInstant(query.to, "to");
+  assertRange(fromMs, toMs, maxRangeDays);
+  const categories = query.categories ? new Set(query.categories) : undefined;
+  const matched = filterRange(cards, fromMs, toMs, categories, query.includeDistractions === true);
+  if (query.format === "compact") return toCompact(matched, query.from);
+  return matched;
+}
+
+function haystack(card: TimelineQueryCard): string {
+  const parts = [card.title, card.summary];
+  if (card.detailedSummary) parts.push(card.detailedSummary);
+  return parts.join(" ").toLowerCase();
+}
+
+function tokenMatchCount(card: TimelineQueryCard, tokens: readonly string[]): number {
+  const text = haystack(card);
+  let count = 0;
+  for (const token of tokens) {
+    if (text.includes(token)) count += 1;
+  }
+  return count;
+}
+
+export function queryTimelineSearch(
+  cards: readonly TimelineQueryCard[] | null | undefined,
+  query: TimelineSearchQuery,
+): TimelineSearchResult {
+  if (!Array.isArray(cards)) return { ok: false, error: "store_unreadable" };
+  const tokens = query.query.trim().toLowerCase().split(/\s+/).filter(Boolean);
+  const limit = query.limit ?? DEFAULT_SEARCH_LIMIT;
+  if (!Number.isInteger(limit) || limit < MIN_SEARCH_LIMIT || limit > MAX_SEARCH_LIMIT) {
+    throw new RangeError(`limit must be an integer from ${MIN_SEARCH_LIMIT} to ${MAX_SEARCH_LIMIT}`);
+  }
+  let pool = cards;
+  if (query.from !== undefined || query.to !== undefined) {
+    const fromMs = parseInstant(query.from ?? query.to!, "from");
+    const toMs = parseInstant(query.to ?? query.from!, "to");
+    assertRange(fromMs, toMs, DEFAULT_MAX_RANGE_DAYS);
+    pool = filterRange(cards, fromMs, toMs, undefined, true);
+  }
+  if (tokens.length === 0) return { ok: true, results: [] };
+  const ranked = pool
+    .map((card) => ({ card, matches: tokenMatchCount(card, tokens) }))
+    .filter((row) => row.matches > 0)
+    .sort((a, b) => {
+      if (a.matches !== b.matches) return b.matches - a.matches;
+      const recency = Date.parse(b.card.endUtc) - Date.parse(a.card.endUtc);
+      if (recency !== 0) return recency;
+      return a.card.id < b.card.id ? -1 : a.card.id > b.card.id ? 1 : 0;
+    })
+    .slice(0, limit)
+    .map((row) => row.card);
+  return { ok: true, results: ranked };
+}
+
+function parseFlags(args: string[]): { flags: Map<string, string | true>; positional: string[] } {
+  const flags = new Map<string, string | true>();
+  const positional: string[] = [];
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i]!;
+    if (!arg.startsWith("--")) {
+      positional.push(arg);
+      continue;
+    }
+    if (VALUE_FLAGS[arg] === true) {
+      const value = args[i + 1];
+      if (value === undefined || value.startsWith("--")) {
+        throw new TypeError(`flag ${arg} requires a value`);
+      }
+      flags.set(arg, value);
+      i += 1;
+      continue;
+    }
+    if (BOOLEAN_FLAGS[arg] === true) {
+      flags.set(arg, true);
+      continue;
+    }
+    const known = [...Object.keys(VALUE_FLAGS), ...Object.keys(BOOLEAN_FLAGS)].sort().join(", ");
+    throw new TypeError(`unknown flag ${arg} (valid: ${known})`);
+  }
+  return { flags, positional };
+}
+
+function flagString(flags: Map<string, string | true>, name: string): string | undefined {
+  const value = flags.get(name);
+  return typeof value === "string" ? value : undefined;
+}
+
+/** Shared CLI runner. `deps.cards` may be an in-memory fixture. */
+export async function runTimelineCliCommand(
+  deps: TimelineCliDeps,
+  args: string[],
+  io: TimelineCliIo,
+): Promise<number> {
+  const [command, ...rest] = args;
+  try {
+    if (command === undefined || command === "help" || command === "--help") {
+      io.stdout.write(USAGE);
+      return command === undefined ? 1 : 0;
+    }
+    if (deps.timelineEnabled === false || !deps.qa.enabled) {
+      io.stderr.write("timeline qa disabled — set activity.timeline.qa.enabled=true\n");
+      return 1;
+    }
+    const { flags } = parseFlags(rest);
+    if (command === "range") {
+      const from = flagString(flags, "--from");
+      const to = flagString(flags, "--to");
+      if (!from || !to) throw new TypeError("range requires --from and --to");
+      if (!Array.isArray(deps.cards)) {
+        io.stderr.write("store_unreadable\n");
+        return 1;
+      }
+      const formatRaw = flagString(flags, "--format") ?? "compact";
+      if (formatRaw !== "cards" && formatRaw !== "compact") {
+        throw new TypeError("format must be one of: cards, compact");
+      }
+      const categoriesRaw = flagString(flags, "--categories");
+      const result = queryTimelineRange(deps.cards, {
+        from,
+        to,
+        format: formatRaw,
+        categories: categoriesRaw ? categoriesRaw.split(",").filter(Boolean) : undefined,
+        includeDistractions: flags.get("--include-distractions") === true,
+        maxRangeDays: deps.qa.maxRangeDays,
+      });
+      io.stdout.write(`${JSON.stringify(result)}\n`);
+      return 0;
+    }
+    if (command === "search") {
+      const q = flagString(flags, "--query");
+      if (q === undefined) throw new TypeError("search requires --query");
+      const limitRaw = flagString(flags, "--limit");
+      const limit = limitRaw === undefined ? undefined : Number(limitRaw);
+      if (limitRaw !== undefined && !Number.isInteger(limit)) {
+        throw new RangeError("limit must be an integer from 1 to 50");
+      }
+      const result = queryTimelineSearch(deps.cards, {
+        query: q,
+        from: flagString(flags, "--from"),
+        to: flagString(flags, "--to"),
+        limit,
+      });
+      io.stdout.write(`${JSON.stringify(result)}\n`);
+      return result.ok ? 0 : 1;
+    }
+    throw new TypeError(`unknown command ${command} (valid: range, search)`);
+  } catch (err) {
+    io.stderr.write(`${err instanceof Error ? err.message : String(err)}\n`);
+    return 1;
+  }
+}