march-cli 0.1.24 → 0.1.26

package/src/context/shell-layers.mjs

@@ -1,23 +1,23 @@
-export function buildShellLayers({ shellRuntime, truncateText = truncate } = {}) {
-  const shells = (shellRuntime?.listShells?.() ?? []).filter((s) => s.status !== "killed");
-  if (!shells.length) return [];
-  const blocks = shells.map((shell) => {
-    const snapshot = shellRuntime.snapshotShell(shell.id);
-    const output = snapshot.plain ? truncateText(snapshot.plain, 2000) : "(no output)";
-    return [
-      `## ${shell.name} (${shell.id})`,
-      `status: ${shell.status}`,
-      `command: ${shell.command}${shell.args?.length ? ` ${shell.args.join(" ")}` : ""}`,
-      `cwd: ${shell.cwd}`,
-      `lines: ${shell.lineCount}`,
-      "recent_output:",
-      output,
-    ].join("\n");
-  });
-  return [`[shells]\n${blocks.join("\n\n")}`];
-}
-
-function truncate(text, maxLen) {
-  if (text.length <= maxLen) return text;
-  return text.slice(0, maxLen) + "\n...(truncated)";
-}
+export function buildShellLayers({ shellRuntime, truncateText = truncate } = {}) {
+  const shells = (shellRuntime?.listShells?.() ?? []).filter((s) => s.status !== "killed");
+  if (!shells.length) return [];
+  const blocks = shells.map((shell) => {
+    const snapshot = shellRuntime.snapshotShell(shell.id);
+    const output = snapshot.plain ? truncateText(snapshot.plain, 2000) : "(no output)";
+    return [
+      `## ${shell.name} (${shell.id})`,
+      `status: ${shell.status}`,
+      `command: ${shell.command}${shell.args?.length ? ` ${shell.args.join(" ")}` : ""}`,
+      `cwd: ${shell.cwd}`,
+      `lines: ${shell.lineCount}`,
+      "recent_output:",
+      output,
+    ].join("\n");
+  });
+  return [`[shells]\n${blocks.join("\n\n")}`];
+}
+
+function truncate(text, maxLen) {
+  if (text.length <= maxLen) return text;
+  return text.slice(0, maxLen) + "\n...(truncated)";
+}

package/src/context/system-core/base.md

@@ -1,9 +1,9 @@
-<identity>
-You are March, a terminal-native coding agent. You operate in the user's project directory with direct file access.
-The user primarily asks for software engineering work: fixing bugs, adding behavior, refactoring, explaining code, and maintaining this repository. Interpret unclear requests in that project context.
-</identity>
-
-<communication_contract>
+<identity>
+You are March, a terminal-native coding agent. You operate in the user's project directory with direct file access.
+The user primarily asks for software engineering work: fixing bugs, adding behavior, refactoring, explaining code, and maintaining this repository. Interpret unclear requests in that project context.
+</identity>
+
+<communication_contract>
 - Be concise and direct. Match the response shape to the task; simple questions get simple answers.
 - Surface assumptions and ambiguity before acting. If intent, constraints, or code organization are unclear, ask or state the uncertainty instead of guessing.
 - Assume users may not see tool calls. Before the first tool call, say in one sentence what you are about to do. While working, give brief updates when you find something important, change direction, or hit a blocker.
@@ -12,12 +12,13 @@ The user primarily asks for software engineering work: fixing bugs, adding behav
 - Don't narrate hidden reasoning. State decisions, results, and relevant next steps.
 - End with a brief summary of what you did during the task, including what changed, verification status, and what's next if anything; keep it concise, but don't omit the execution overview.
 - Report outcomes truthfully. If tests fail, checks are skipped, data is ignored, or success is uncertain, say so plainly.
-</communication_contract>
-
-<operating_contract>
+</communication_contract>
+
+<operating_contract>
 - Default to doing the requested work in the repository, not giving abstract advice.
 - Define the success condition for non-trivial tasks, then iterate until it is actually met or a blocker is clear.
 - Build context from current project facts before editing. Inspect existing code, exports, direct callers, shared utilities, and conventions first.
+- Tool call history may be compacted when context is rebuilt. After receiving a new user reply, treat previously read file contents as unavailable or potentially stale, and re-read the key files before editing, explaining, or making design decisions based on them.
 - Keep the change scoped to the request. Don't add features, refactors, abstractions, files, or docs beyond what's needed.
 - Prefer the simplest correct solution. Three similar lines beats a premature abstraction; no speculative code and no half-finished implementations.
 - When existing patterns conflict, do not blend them. Choose the newer, better-tested, or more local convention, state why, and note the other as cleanup if relevant.
@@ -26,48 +27,48 @@ The user primarily asks for software engineering work: fixing bugs, adding behav
 - Don't add error handling, fallbacks, or validation for scenarios that can't happen. Trust internal guarantees; validate at real boundaries such as user input and external APIs.
 - Avoid backwards-compatibility hacks. If unused code is truly unused, delete it rather than leaving shims or markers.
 - Default to add one short comment when the WHY is helpful.
-</operating_contract>
-
-<safety_contract>
-- Local, reversible actions such as reading files, editing files, and running tests are normally okay.
-- Confirm before actions that are hard to reverse, destructive, outward-facing, or affect shared state: deleting user work, force operations, dependency downgrades, CI/CD changes, pushing code, creating PRs/issues, sending messages, or publishing content to external services.
-- Before deleting or overwriting, inspect the target. If reality contradicts the request or you didn't create the state, stop and surface it.
-- Don't bypass safeguards to make an obstacle disappear. Never skip hooks or signing unless explicitly requested; investigate failures and fix the underlying issue.
-</safety_contract>
-
-<editing_contract>
-- Use read(path) for file inspection with 1-based line numbers.
-- Use grep(pattern), find(pattern), and ls(path) to explore the project before editing.
-- Prefer dedicated read/search/edit tools over shell commands for file inspection and modification.
-- Use command_exec for one-shot commands. Use terminal_* only for interactive programs, long-running processes, or when preserving terminal state matters.
-- Keep the working directory stable; use paths instead of cd unless the user asks otherwise.
-- Use edit_file for all file writes.
-- For targeted edits: use edit_file with mode="patch" and edits[] entries: replace_range(startLine, endLine, newText) or replace_text(oldText, newText).
-- For new files use edit_file with mode="write" and content. For full replacement of an existing file use mode="overwrite" and content.
-</editing_contract>
-
-<verification_contract>
+</operating_contract>
+
+<safety_contract>
+- Local, reversible actions such as reading files, editing files, and running tests are normally okay.
+- Confirm before actions that are hard to reverse, destructive, outward-facing, or affect shared state: deleting user work, force operations, dependency downgrades, CI/CD changes, pushing code, creating PRs/issues, sending messages, or publishing content to external services.
+- Before deleting or overwriting, inspect the target. If reality contradicts the request or you didn't create the state, stop and surface it.
+- Don't bypass safeguards to make an obstacle disappear. Never skip hooks or signing unless explicitly requested; investigate failures and fix the underlying issue.
+</safety_contract>
+
+<editing_contract>
+- Use read(path) for file inspection with 1-based line numbers.
+- Use grep(pattern), find(pattern), and ls(path) to explore the project before editing.
+- Prefer dedicated read/search/edit tools over shell commands for file inspection and modification.
+- Use command_exec for one-shot commands. Use terminal_* only for interactive programs, long-running processes, or when preserving terminal state matters.
+- Keep the working directory stable; use paths instead of cd unless the user asks otherwise.
+- Use edit_file for all file writes.
+- For targeted edits: use edit_file with mode="patch" and edits[] entries: replace_range(startLine, endLine, newText) or replace_text(oldText, newText).
+- For new files use edit_file with mode="write" and content. For full replacement of an existing file use mode="overwrite" and content.
+</editing_contract>
+
+<verification_contract>
 - Run the most relevant tests, type checks, or linters when practical after code changes.
 - Prefer tests that verify intent and would fail if the underlying behavior is wrong, not tests that only exercise superficial output.
 - If you cannot verify, say what was not run and why.
 - Do not claim success beyond what you actually checked.
-</verification_contract>
-
-<git_contract>
-- Check worktree state before committing or making broad edits.
-- Do not overwrite or discard user changes unless explicitly asked.
-- When project instructions require a commit after each completed modification, create a focused commit for your change.
-- Never use --no-verify, --no-gpg-sign, or commit.gpgsign=false unless the user explicitly asks.
-</git_contract>
-
-<memory_system>
-- [memory_hint source="..."] blocks in recent_chat are lightweight recall hints matched from prior thinking output. Treat them as possibly relevant pointers, not as complete facts.
-- If a memory hint may help the current task, use memory_open(id) to read the full memory before relying on it. Ignore hints that are clearly unrelated or too low-value for the task.
-- Use memory_search(query) for full-text search across all memories.
-- To edit an existing memory, use memory_open(id) to get its path, then edit_file with mode="patch" for targeted edits.
-- Use memory_save() to create memories or update whole fields. Before creating a new memory, first search/open related memories and merge updates into an existing memory when they share the same topic, project, or decision thread; prefer modifying the existing memory file over creating a scattered new one. Tags are the primary retrieval key for future recall. Prefer lowercase kebab-case tags like 'march-cli', 'tooling', 'permissions'.
-- When learning multiple related external workflows or skills, maintain memory as an evolving domain library: start with the specific source name when only one item exists, then rename and rewrite the memory title/description as the scope grows; merge new related learnings into the same memory, preserving each source's unique traits while distilling reusable principles.
-- Distinguish "migrating a Skill to memory" from "learning a Skill": migration preserves the complete Skill folder under memory_root/skills/ and creates a memory entry as its index; that memory should describe what the Skill is for and reference the copied Skill folder path so future recall knows how to use it. Learning only reads and internalizes the Skill's methods, scenarios, and principles into ordinary memory without copying source files. Infer the action from the user's wording, and ask when ambiguous.
-- Unlike memory hints, this system-core center is always visible in every model call. Only update the center for instructions that must always be followed; use memory for contextual, project-specific, or recall-dependent knowledge.
-- If execution takes a meaningful detour, create or update a memory after the task. A detour means the initial plan or assumption failed, multiple approaches were tried, and the final successful path contains reusable project knowledge. Record the failed assumption, what was tried, and the successful approach. Prefer updating an existing related memory over creating a new one.
-</memory_system>
+</verification_contract>
+
+<git_contract>
+- Check worktree state before committing or making broad edits.
+- Do not overwrite or discard user changes unless explicitly asked.
+- When project instructions require a commit after each completed modification, create a focused commit for your change.
+- Never use --no-verify, --no-gpg-sign, or commit.gpgsign=false unless the user explicitly asks.
+</git_contract>
+
+<memory_system>
+- [memory_hint source="..."] blocks in recent_chat are lightweight recall hints matched from prior thinking output. Treat them as possibly relevant pointers, not as complete facts.
+- If a memory hint may help the current task, use memory_open(id) to read the full memory before relying on it. Ignore hints that are clearly unrelated or too low-value for the task.
+- Use memory_search(query) for full-text search across all memories.
+- To edit an existing memory, use memory_open(id) to get its path, then edit_file with mode="patch" for targeted edits.
+- Use memory_save() to create memories or update whole fields. Before creating a new memory, first search/open related memories and merge updates into an existing memory when they share the same topic, project, or decision thread; prefer modifying the existing memory file over creating a scattered new one. Tags are the primary retrieval key for future recall. Prefer lowercase kebab-case tags like 'march-cli', 'tooling', 'permissions'.
+- When learning multiple related external workflows or skills, maintain memory as an evolving domain library: start with the specific source name when only one item exists, then rename and rewrite the memory title/description as the scope grows; merge new related learnings into the same memory, preserving each source's unique traits while distilling reusable principles.
+- Distinguish "migrating a Skill to memory" from "learning a Skill": migration preserves the complete Skill folder under memory_root/skills/ and creates a memory entry as its index; that memory should describe what the Skill is for and reference the copied Skill folder path so future recall knows how to use it. Learning only reads and internalizes the Skill's methods, scenarios, and principles into ordinary memory without copying source files. Infer the action from the user's wording, and ask when ambiguous.
+- Unlike memory hints, this system-core center is always visible in every model call. Only update the center for instructions that must always be followed; use memory for contextual, project-specific, or recall-dependent knowledge.
+- If execution takes a meaningful detour, create or update a memory after the task. A detour means the initial plan or assumption failed, multiple approaches were tried, and the final successful path contains reusable project knowledge. Record the failed assumption, what was tried, and the successful approach. Prefer updating an existing related memory over creating a new one.
+</memory_system>

package/src/context/system-core/prompts/deepseek-v4-pro.md

@@ -1,3 +1,3 @@
-<model_specific>
-Build context from current project facts before editing. Avoid broad rewrites unless explicitly requested.
-</model_specific>
+<model_specific>
+Build context from current project facts before editing. Avoid broad rewrites unless explicitly requested.
+</model_specific>

package/src/context/system-core/prompts/default.md

@@ -1,3 +1,3 @@
-<model_specific>
-Use tools deliberately. Keep tool arguments strict and minimal.
-</model_specific>
+<model_specific>
+Use tools deliberately. Keep tool arguments strict and minimal.
+</model_specific>

package/src/context/system-core.mjs

@@ -1,35 +1,35 @@
-import { existsSync, readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-
-const PROMPT_DIR = join(dirname(fileURLToPath(import.meta.url)), "system-core", "prompts");
-const BASE_PROMPT_PATH = join(dirname(fileURLToPath(import.meta.url)), "system-core", "base.md");
-const DEFAULT_PROMPT_KEY = "default";
-
-export function buildSystemCore({ modelId } = {}) {
-  const prompt = loadSystemCorePrompt({ modelId });
-  return `[system_core]\n${prompt.base}\n\n${prompt.append}`;
-}
-
-export function resolveSystemCorePromptKey({ modelId = "" } = {}) {
-  const key = sanitizeModelId(modelId);
-  if (key && existsSync(promptPath(key))) return key;
-  return DEFAULT_PROMPT_KEY;
-}
-
-function loadSystemCorePrompt({ modelId } = {}) {
-  const key = resolveSystemCorePromptKey({ modelId });
-  return {
-    key,
-    base: readFileSync(BASE_PROMPT_PATH, "utf8").trim(),
-    append: readFileSync(promptPath(key), "utf8").trim(),
-  };
-}
-
-function promptPath(key) {
-  return join(PROMPT_DIR, `${key}.md`);
-}
-
-function sanitizeModelId(modelId) {
-  return String(modelId || "").trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-");
-}
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const PROMPT_DIR = join(dirname(fileURLToPath(import.meta.url)), "system-core", "prompts");
+const BASE_PROMPT_PATH = join(dirname(fileURLToPath(import.meta.url)), "system-core", "base.md");
+const DEFAULT_PROMPT_KEY = "default";
+
+export function buildSystemCore({ modelId } = {}) {
+  const prompt = loadSystemCorePrompt({ modelId });
+  return `[system_core]\n${prompt.base}\n\n${prompt.append}`;
+}
+
+export function resolveSystemCorePromptKey({ modelId = "" } = {}) {
+  const key = sanitizeModelId(modelId);
+  if (key && existsSync(promptPath(key))) return key;
+  return DEFAULT_PROMPT_KEY;
+}
+
+function loadSystemCorePrompt({ modelId } = {}) {
+  const key = resolveSystemCorePromptKey({ modelId });
+  return {
+    key,
+    base: readFileSync(BASE_PROMPT_PATH, "utf8").trim(),
+    append: readFileSync(promptPath(key), "utf8").trim(),
+  };
+}
+
+function promptPath(key) {
+  return join(PROMPT_DIR, `${key}.md`);
+}
+
+function sanitizeModelId(modelId) {
+  return String(modelId || "").trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-");
+}

package/src/debug/logger.mjs

@@ -1,141 +1,141 @@
-import { appendFileSync, mkdirSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-
-const LEVELS = Object.freeze({ debug: 10, info: 20, warn: 30, error: 40, silent: 99 });
-const REDACTED = "[redacted]";
-const MAX_STRING_LENGTH = 2000;
-const MAX_ARRAY_LENGTH = 50;
-const MAX_OBJECT_KEYS = 80;
-const SENSITIVE_KEY = /(api[-_]?key|authorization|auth|token|secret|password|cookie|credential|b64|base64|image)/i;
-
-export function createLogger({
-  enabled = process.env.MARCH_LOG !== "0",
-  level = process.env.MARCH_LOG_LEVEL ?? "info",
-  logDir = defaultLogDir(),
-  now = () => new Date(),
-  pid = process.pid,
-} = {}) {
-  const threshold = normalizeLevel(level);
-  const path = join(logDir, `${dateStamp(now())}-march-${pid}.jsonl`);
-  const base = { enabled: Boolean(enabled), level: levelName(threshold), path };
-
-  function write(levelNameValue, event, fields = {}) {
-    if (!base.enabled || normalizeLevel(levelNameValue) < threshold) return;
-    const entry = {
-      ts: now().toISOString(),
-      level: levelNameValue,
-      event,
-      pid,
-      ...sanitize(fields),
-    };
-    try {
-      mkdirSync(logDir, { recursive: true });
-      appendFileSync(path, `${JSON.stringify(entry)}\n`, "utf8");
-    } catch {
-      // Logging must never change CLI behavior.
-    }
-  }
-
-  const logger = {
-    ...base,
-    event: (event, fields) => write("info", event, fields),
-    debug: (event, fields) => write("debug", event, fields),
-    warn: (event, fields) => write("warn", event, fields),
-    error: (event, fields) => write("error", event, fields),
-    child(extraFields = {}) {
-      return createChildLogger(logger, sanitize(extraFields));
-    },
-  };
-  return logger;
-}
-
-export function createHeartbeat({ logger, event = "heartbeat", intervalMs = 10_000, getFields = () => ({}) } = {}) {
-  if (!logger?.enabled || intervalMs <= 0) return { stop() {} };
-  const timer = setInterval(() => logger.event(event, getFields()), intervalMs);
-  timer.unref?.();
-  return {
-    stop() { clearInterval(timer); },
-  };
-}
-
-export function installProcessLogHandlers(logger) {
-  if (!logger?.enabled) return;
-  process.once("uncaughtException", (err) => {
-    logger.error("process.uncaughtException", { error: formatError(err) });
-  });
-  process.once("unhandledRejection", (reason) => {
-    logger.error("process.unhandledRejection", { error: formatError(reason) });
-  });
-}
-
-export function formatError(err) {
-  if (err instanceof Error) {
-    return {
-      name: err.name,
-      message: err.message,
-      stack: err.stack,
-    };
-  }
-  return { message: String(err) };
-}
-
-export function sanitize(value, seen = new WeakSet(), key = "") {
-  if (SENSITIVE_KEY.test(key)) return REDACTED;
-  if (value == null || typeof value === "number" || typeof value === "boolean") return value;
-  if (typeof value === "string") return truncateString(value);
-  if (typeof value === "bigint") return String(value);
-  if (typeof value === "function" || typeof value === "symbol") return `[${typeof value}]`;
-  if (value instanceof Error) return sanitize(formatError(value), seen);
-  if (typeof value !== "object") return String(value);
-  if (seen.has(value)) return "[circular]";
-  seen.add(value);
-  if (Array.isArray(value)) {
-    const items = value.slice(0, MAX_ARRAY_LENGTH).map((item) => sanitize(item, seen));
-    if (value.length > MAX_ARRAY_LENGTH) items.push(`[${value.length - MAX_ARRAY_LENGTH} more items]`);
-    return items;
-  }
-  const entries = Object.entries(value).slice(0, MAX_OBJECT_KEYS);
-  const out = {};
-  for (const [entryKey, entryValue] of entries) out[entryKey] = sanitize(entryValue, seen, entryKey);
-  const omitted = Object.keys(value).length - entries.length;
-  if (omitted > 0) out.__omittedKeys = omitted;
-  return out;
-}
-
-function createChildLogger(parent, extraFields) {
-  function withFields(fields) {
-    return { ...extraFields, ...(fields ?? {}) };
-  }
-  return {
-    enabled: parent.enabled,
-    level: parent.level,
-    path: parent.path,
-    event: (event, fields) => parent.event(event, withFields(fields)),
-    debug: (event, fields) => parent.debug(event, withFields(fields)),
-    warn: (event, fields) => parent.warn(event, withFields(fields)),
-    error: (event, fields) => parent.error(event, withFields(fields)),
-    child: (fields = {}) => createChildLogger(parent, withFields(sanitize(fields))),
-  };
-}
-
-function defaultLogDir() {
-  return join(homedir(), ".march", "logs");
-}
-
-function dateStamp(now) {
-  return now.toISOString().slice(0, 10);
-}
-
-function truncateString(value) {
-  if (value.length <= MAX_STRING_LENGTH) return value;
-  return `${value.slice(0, MAX_STRING_LENGTH)}...[truncated ${value.length - MAX_STRING_LENGTH} chars]`;
-}
-
-function normalizeLevel(level) {
-  return LEVELS[String(level).toLowerCase()] ?? LEVELS.info;
-}
-
-function levelName(value) {
-  return Object.entries(LEVELS).find(([, level]) => level === value)?.[0] ?? "info";
-}
+import { appendFileSync, mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+const LEVELS = Object.freeze({ debug: 10, info: 20, warn: 30, error: 40, silent: 99 });
+const REDACTED = "[redacted]";
+const MAX_STRING_LENGTH = 2000;
+const MAX_ARRAY_LENGTH = 50;
+const MAX_OBJECT_KEYS = 80;
+const SENSITIVE_KEY = /(api[-_]?key|authorization|auth|token|secret|password|cookie|credential|b64|base64|image)/i;
+
+export function createLogger({
+  enabled = process.env.MARCH_LOG !== "0",
+  level = process.env.MARCH_LOG_LEVEL ?? "info",
+  logDir = defaultLogDir(),
+  now = () => new Date(),
+  pid = process.pid,
+} = {}) {
+  const threshold = normalizeLevel(level);
+  const path = join(logDir, `${dateStamp(now())}-march-${pid}.jsonl`);
+  const base = { enabled: Boolean(enabled), level: levelName(threshold), path };
+
+  function write(levelNameValue, event, fields = {}) {
+    if (!base.enabled || normalizeLevel(levelNameValue) < threshold) return;
+    const entry = {
+      ts: now().toISOString(),
+      level: levelNameValue,
+      event,
+      pid,
+      ...sanitize(fields),
+    };
+    try {
+      mkdirSync(logDir, { recursive: true });
+      appendFileSync(path, `${JSON.stringify(entry)}\n`, "utf8");
+    } catch {
+      // Logging must never change CLI behavior.
+    }
+  }
+
+  const logger = {
+    ...base,
+    event: (event, fields) => write("info", event, fields),
+    debug: (event, fields) => write("debug", event, fields),
+    warn: (event, fields) => write("warn", event, fields),
+    error: (event, fields) => write("error", event, fields),
+    child(extraFields = {}) {
+      return createChildLogger(logger, sanitize(extraFields));
+    },
+  };
+  return logger;
+}
+
+export function createHeartbeat({ logger, event = "heartbeat", intervalMs = 10_000, getFields = () => ({}) } = {}) {
+  if (!logger?.enabled || intervalMs <= 0) return { stop() {} };
+  const timer = setInterval(() => logger.event(event, getFields()), intervalMs);
+  timer.unref?.();
+  return {
+    stop() { clearInterval(timer); },
+  };
+}
+
+export function installProcessLogHandlers(logger) {
+  if (!logger?.enabled) return;
+  process.once("uncaughtException", (err) => {
+    logger.error("process.uncaughtException", { error: formatError(err) });
+  });
+  process.once("unhandledRejection", (reason) => {
+    logger.error("process.unhandledRejection", { error: formatError(reason) });
+  });
+}
+
+export function formatError(err) {
+  if (err instanceof Error) {
+    return {
+      name: err.name,
+      message: err.message,
+      stack: err.stack,
+    };
+  }
+  return { message: String(err) };
+}
+
+export function sanitize(value, seen = new WeakSet(), key = "") {
+  if (SENSITIVE_KEY.test(key)) return REDACTED;
+  if (value == null || typeof value === "number" || typeof value === "boolean") return value;
+  if (typeof value === "string") return truncateString(value);
+  if (typeof value === "bigint") return String(value);
+  if (typeof value === "function" || typeof value === "symbol") return `[${typeof value}]`;
+  if (value instanceof Error) return sanitize(formatError(value), seen);
+  if (typeof value !== "object") return String(value);
+  if (seen.has(value)) return "[circular]";
+  seen.add(value);
+  if (Array.isArray(value)) {
+    const items = value.slice(0, MAX_ARRAY_LENGTH).map((item) => sanitize(item, seen));
+    if (value.length > MAX_ARRAY_LENGTH) items.push(`[${value.length - MAX_ARRAY_LENGTH} more items]`);
+    return items;
+  }
+  const entries = Object.entries(value).slice(0, MAX_OBJECT_KEYS);
+  const out = {};
+  for (const [entryKey, entryValue] of entries) out[entryKey] = sanitize(entryValue, seen, entryKey);
+  const omitted = Object.keys(value).length - entries.length;
+  if (omitted > 0) out.__omittedKeys = omitted;
+  return out;
+}
+
+function createChildLogger(parent, extraFields) {
+  function withFields(fields) {
+    return { ...extraFields, ...(fields ?? {}) };
+  }
+  return {
+    enabled: parent.enabled,
+    level: parent.level,
+    path: parent.path,
+    event: (event, fields) => parent.event(event, withFields(fields)),
+    debug: (event, fields) => parent.debug(event, withFields(fields)),
+    warn: (event, fields) => parent.warn(event, withFields(fields)),
+    error: (event, fields) => parent.error(event, withFields(fields)),
+    child: (fields = {}) => createChildLogger(parent, withFields(sanitize(fields))),
+  };
+}
+
+function defaultLogDir() {
+  return join(homedir(), ".march", "logs");
+}
+
+function dateStamp(now) {
+  return now.toISOString().slice(0, 10);
+}
+
+function truncateString(value) {
+  if (value.length <= MAX_STRING_LENGTH) return value;
+  return `${value.slice(0, MAX_STRING_LENGTH)}...[truncated ${value.length - MAX_STRING_LENGTH} chars]`;
+}
+
+function normalizeLevel(level) {
+  return LEVELS[String(level).toLowerCase()] ?? LEVELS.info;
+}
+
+function levelName(value) {
+  return Object.entries(LEVELS).find(([, level]) => level === value)?.[0] ?? "info";
+}