gsd-pi 2.45.0-dev.6b9da3e → 2.45.0-dev.e0ee972

package/src/resources/extensions/gsd/tests/workflow-logger.test.ts

@@ -0,0 +1,275 @@
+// GSD Extension — Workflow Logger Tests
+// Tests for the centralized warning/error accumulator.
+
+import { describe, test, beforeEach } from "node:test";
+import assert from "node:assert/strict";
+import {
+  logWarning,
+  logError,
+  drainLogs,
+  drainAndSummarize,
+  peekLogs,
+  hasErrors,
+  hasWarnings,
+  hasAnyIssues,
+  summarizeLogs,
+  formatForNotification,
+  _resetLogs,
+} from "../workflow-logger.ts";
+
+const ISO_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
+
+describe("workflow-logger", () => {
+  beforeEach(() => {
+    _resetLogs();
+  });
+
+  describe("accumulation", () => {
+    test("logWarning adds an entry with severity warn", () => {
+      logWarning("engine", "test warning");
+      const entries = peekLogs();
+      assert.equal(entries.length, 1);
+      assert.equal(entries[0].severity, "warn");
+      assert.equal(entries[0].component, "engine");
+      assert.equal(entries[0].message, "test warning");
+      assert.match(entries[0].ts, ISO_RE);
+    });
+
+    test("logError adds an entry with severity error", () => {
+      logError("intercept", "blocked write", { path: "/foo/STATE.md" });
+      const entries = peekLogs();
+      assert.equal(entries.length, 1);
+      assert.equal(entries[0].severity, "error");
+      assert.equal(entries[0].component, "intercept");
+      assert.deepEqual(entries[0].context, { path: "/foo/STATE.md" });
+    });
+
+    test("accumulates multiple entries in order", () => {
+      logWarning("projection", "render failed");
+      logError("intercept", "blocked write");
+      logWarning("manifest", "write failed");
+      assert.equal(peekLogs().length, 3);
+      assert.equal(peekLogs()[0].component, "projection");
+      assert.equal(peekLogs()[1].component, "intercept");
+      assert.equal(peekLogs()[2].component, "manifest");
+    });
+
+    test("omits context field when not provided", () => {
+      logWarning("engine", "no context");
+      assert.equal("context" in peekLogs()[0], false);
+    });
+
+    test("omits context field when undefined is passed", () => {
+      logWarning("engine", "no context", undefined);
+      assert.equal("context" in peekLogs()[0], false);
+    });
+
+    test("context with special characters is stored as-is", () => {
+      logError("tool", "failed", { path: '/foo/"quoted".md', msg: "line1\nline2" });
+      assert.deepEqual(peekLogs()[0].context, {
+        path: '/foo/"quoted".md',
+        msg: "line1\nline2",
+      });
+    });
+
+    test("ts field is a valid ISO 8601 timestamp", () => {
+      logWarning("engine", "ts check");
+      assert.match(peekLogs()[0].ts, ISO_RE);
+    });
+  });
+
+  describe("drain", () => {
+    test("returns all entries and clears buffer", () => {
+      logWarning("engine", "w1");
+      logError("engine", "e1");
+      const drained = drainLogs();
+      assert.equal(drained.length, 2);
+      assert.equal(peekLogs().length, 0);
+    });
+
+    test("returns empty array when no entries", () => {
+      assert.deepEqual(drainLogs(), []);
+    });
+
+    test("second drain returns empty array", () => {
+      logWarning("engine", "w1");
+      drainLogs();
+      assert.deepEqual(drainLogs(), []);
+    });
+  });
+
+  describe("drainAndSummarize", () => {
+    test("returns summary and clears buffer atomically", () => {
+      logError("intercept", "blocked");
+      logWarning("projection", "render failed");
+      const { logs, summary } = drainAndSummarize();
+      assert.equal(logs.length, 2);
+      assert.equal(peekLogs().length, 0);
+      assert.ok(summary?.includes("1 error(s)"));
+      assert.ok(summary?.includes("1 warning(s)"));
+    });
+
+    test("returns null summary when buffer is empty", () => {
+      const { logs, summary } = drainAndSummarize();
+      assert.deepEqual(logs, []);
+      assert.equal(summary, null);
+    });
+  });
+
+  describe("hasErrors / hasWarnings / hasAnyIssues", () => {
+    test("hasErrors returns false when only warnings", () => {
+      logWarning("engine", "just a warning");
+      assert.equal(hasErrors(), false);
+      assert.equal(hasWarnings(), true);
+    });
+
+    test("hasErrors returns true when errors present", () => {
+      logWarning("engine", "warning");
+      logError("intercept", "error");
+      assert.equal(hasErrors(), true);
+    });
+
+    test("hasWarnings returns false when buffer empty", () => {
+      assert.equal(hasWarnings(), false);
+    });
+
+    test("hasWarnings returns false when buffer contains only errors", () => {
+      logError("intercept", "only an error");
+      assert.equal(hasWarnings(), false);
+      assert.equal(hasErrors(), true);
+    });
+
+    test("hasAnyIssues returns true for warnings only", () => {
+      logWarning("engine", "warn");
+      assert.equal(hasAnyIssues(), true);
+    });
+
+    test("hasAnyIssues returns true for errors only", () => {
+      logError("engine", "err");
+      assert.equal(hasAnyIssues(), true);
+    });
+
+    test("hasAnyIssues returns false when buffer empty", () => {
+      assert.equal(hasAnyIssues(), false);
+    });
+  });
+
+  describe("summarizeLogs", () => {
+    test("returns null when empty", () => {
+      assert.equal(summarizeLogs(), null);
+    });
+
+    test("summarizes errors and warnings separately", () => {
+      logError("intercept", "blocked STATE.md");
+      logWarning("projection", "render failed");
+      logWarning("manifest", "write failed");
+      const summary = summarizeLogs()!;
+      assert.ok(summary.includes("1 error(s)"));
+      assert.ok(summary.includes("blocked STATE.md"));
+      assert.ok(summary.includes("2 warning(s)"));
+    });
+
+    test("only shows errors section when no warnings", () => {
+      logError("intercept", "blocked");
+      const summary = summarizeLogs()!;
+      assert.ok(summary.includes("1 error(s)"));
+      assert.ok(!summary.includes("warning"));
+    });
+
+    test("only shows warnings section when no errors", () => {
+      logWarning("projection", "render degraded");
+      logWarning("manifest", "write slow");
+      const summary = summarizeLogs()!;
+      assert.ok(summary.includes("2 warning(s)"));
+      assert.ok(!summary.includes("error"));
+    });
+
+    test("does not clear buffer", () => {
+      logError("intercept", "blocked");
+      summarizeLogs();
+      assert.equal(peekLogs().length, 1);
+    });
+  });
+
+  describe("formatForNotification", () => {
+    test("returns empty string for empty array", () => {
+      assert.equal(formatForNotification([]), "");
+    });
+
+    test("formats single entry without line breaks", () => {
+      logError("intercept", "blocked write");
+      const entries = drainLogs();
+      const formatted = formatForNotification(entries);
+      assert.equal(formatted, "[intercept] blocked write");
+    });
+
+    test("formats multiple entries with line breaks", () => {
+      logWarning("projection", "render failed");
+      logError("intercept", "blocked write");
+      const entries = drainLogs();
+      const formatted = formatForNotification(entries);
+      assert.ok(formatted.includes("[projection] render failed"));
+      assert.ok(formatted.includes("[intercept] blocked write"));
+      assert.ok(formatted.includes("\n"));
+    });
+
+    test("does not include context in formatted output", () => {
+      logError("tool", "failed", { cmd: "complete_task" });
+      const entries = drainLogs();
+      const formatted = formatForNotification(entries);
+      assert.equal(formatted, "[tool] failed");
+      assert.ok(!formatted.includes("complete_task"));
+    });
+  });
+
+  describe("buffer limit", () => {
+    test("caps at MAX_BUFFER entries, dropping oldest", () => {
+      const OVER = 110;
+      const MAX = 100;
+      for (let i = 0; i < OVER; i++) {
+        logWarning("engine", `msg-${i}`);
+      }
+      const entries = peekLogs();
+      assert.equal(entries.length, MAX);
+      // First MAX entries dropped; oldest surviving = msg-(OVER-MAX)
+      assert.equal(entries[0].message, `msg-${OVER - MAX}`);
+      assert.equal(entries[MAX - 1].message, `msg-${OVER - 1}`);
+    });
+  });
+
+  describe("stderr output", () => {
+    test("writes WARN prefix to stderr for warnings", (t) => {
+      const written: string[] = [];
+      const orig = process.stderr.write.bind(process.stderr);
+      // @ts-ignore — patching for test
+      process.stderr.write = (chunk: string) => { written.push(chunk); return true; };
+      t.after(() => { process.stderr.write = orig; });
+
+      logWarning("engine", "test warn");
+      assert.equal(written.length, 1);
+      assert.ok(written[0].includes("[gsd:engine] WARN: test warn"));
+    });
+
+    test("writes ERROR prefix to stderr for errors", (t) => {
+      const written: string[] = [];
+      const orig = process.stderr.write.bind(process.stderr);
+      // @ts-ignore — patching for test
+      process.stderr.write = (chunk: string) => { written.push(chunk); return true; };
+      t.after(() => { process.stderr.write = orig; });
+
+      logError("intercept", "blocked");
+      assert.ok(written[0].includes("[gsd:intercept] ERROR: blocked"));
+    });
+
+    test("includes serialized context in stderr output", (t) => {
+      const written: string[] = [];
+      const orig = process.stderr.write.bind(process.stderr);
+      // @ts-ignore — patching for test
+      process.stderr.write = (chunk: string) => { written.push(chunk); return true; };
+      t.after(() => { process.stderr.write = orig; });
+
+      logError("tool", "failed", { cmd: "complete_task" });
+      assert.ok(written[0].includes('"cmd":"complete_task"'));
+    });
+  });
+});

package/src/resources/extensions/gsd/tests/worktree-journal-events.test.ts

@@ -0,0 +1,220 @@
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync, readFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import {
+  WorktreeResolver,
+  type WorktreeResolverDeps,
+  type NotifyCtx,
+} from "../worktree-resolver.js";
+import { AutoSession } from "../auto/session.js";
+import type { JournalEntry } from "../journal.js";
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+function makeSession(
+  overrides?: Partial<{ basePath: string; originalBasePath: string }>,
+): AutoSession {
+  const s = new AutoSession();
+  s.basePath = overrides?.basePath ?? "/project";
+  s.originalBasePath = overrides?.originalBasePath ?? "/project";
+  return s;
+}
+
+function makeDeps(
+  overrides?: Partial<WorktreeResolverDeps>,
+): WorktreeResolverDeps {
+  const deps: WorktreeResolverDeps = {
+    isInAutoWorktree: () => false,
+    shouldUseWorktreeIsolation: () => true,
+    getIsolationMode: () => "worktree",
+    mergeMilestoneToMain: () => ({ pushed: false, codeFilesChanged: true }),
+    syncWorktreeStateBack: () => ({ synced: [] }),
+    teardownAutoWorktree: () => {},
+    createAutoWorktree: (_basePath: string, milestoneId: string) =>
+      `/project/.gsd/worktrees/${milestoneId}`,
+    enterAutoWorktree: (_basePath: string, milestoneId: string) =>
+      `/project/.gsd/worktrees/${milestoneId}`,
+    getAutoWorktreePath: () => null,
+    autoCommitCurrentBranch: () => {},
+    getCurrentBranch: () => "main",
+    autoWorktreeBranch: (milestoneId: string) => `milestone/${milestoneId}`,
+    resolveMilestoneFile: (_basePath: string, milestoneId: string) =>
+      `/project/.gsd/milestones/${milestoneId}/${milestoneId}-ROADMAP.md`,
+    readFileSync: () => "# Roadmap\n- [x] S01: Slice one\n",
+    GitServiceImpl: class {
+      constructor() {}
+    } as unknown as WorktreeResolverDeps["GitServiceImpl"],
+    loadEffectiveGSDPreferences: () => ({ preferences: { git: {} } }),
+    invalidateAllCaches: () => {},
+    captureIntegrationBranch: () => {},
+    ...overrides,
+  };
+  return deps;
+}
+
+function makeNotifyCtx(): NotifyCtx {
+  return {
+    notify: () => {},
+  };
+}
+
+/** Read all journal entries from a temp .gsd/journal directory. */
+function readJournalEntries(basePath: string): JournalEntry[] {
+  const journalDir = join(basePath, ".gsd", "journal");
+  try {
+    const files = readdirSync(journalDir).filter(f => f.endsWith(".jsonl")).sort();
+    const entries: JournalEntry[] = [];
+    for (const file of files) {
+      const raw = readFileSync(join(journalDir, file), "utf-8");
+      for (const line of raw.split("\n")) {
+        if (!line.trim()) continue;
+        entries.push(JSON.parse(line) as JournalEntry);
+      }
+    }
+    return entries;
+  } catch {
+    return [];
+  }
+}
+
+// ─── Tests ───────────────────────────────────────────────────────────────────
+
+describe("worktree journal events", () => {
+  let tmp: string;
+  const originalCwd = process.cwd();
+
+  beforeEach(() => {
+    tmp = mkdtempSync(join(tmpdir(), "wt-journal-"));
+  });
+  afterEach(() => {
+    // Restore cwd before cleanup — on Windows, rmSync fails with EPERM
+    // if the process cwd is inside the directory being deleted.
+    try { process.chdir(originalCwd); } catch { /* best-effort */ }
+    rmSync(tmp, { recursive: true, force: true });
+  });
+
+  test("enterMilestone emits worktree-enter on success (new worktree)", () => {
+    const s = makeSession({ basePath: tmp, originalBasePath: tmp });
+    const deps = makeDeps({ getAutoWorktreePath: () => null });
+    const resolver = new WorktreeResolver(s, deps);
+
+    resolver.enterMilestone("M001", makeNotifyCtx());
+
+    const entries = readJournalEntries(tmp);
+    const enter = entries.find(e => e.eventType === "worktree-enter");
+    assert.ok(enter, "worktree-enter event should be emitted");
+    assert.equal(enter!.data?.milestoneId, "M001");
+    assert.equal(enter!.data?.created, true);
+    assert.ok(enter!.data?.wtPath);
+  });
+
+  test("enterMilestone emits worktree-enter with created=false for existing worktree", () => {
+    const s = makeSession({ basePath: tmp, originalBasePath: tmp });
+    const deps = makeDeps({
+      getAutoWorktreePath: () => "/project/.gsd/worktrees/M001",
+    });
+    const resolver = new WorktreeResolver(s, deps);
+
+    resolver.enterMilestone("M001", makeNotifyCtx());
+
+    const entries = readJournalEntries(tmp);
+    const enter = entries.find(e => e.eventType === "worktree-enter");
+    assert.ok(enter, "worktree-enter event should be emitted");
+    assert.equal(enter!.data?.created, false);
+  });
+
+  test("enterMilestone emits worktree-skip when isolation disabled", () => {
+    const s = makeSession({ basePath: tmp, originalBasePath: tmp });
+    const deps = makeDeps({ shouldUseWorktreeIsolation: () => false });
+    const resolver = new WorktreeResolver(s, deps);
+
+    resolver.enterMilestone("M001", makeNotifyCtx());
+
+    const entries = readJournalEntries(tmp);
+    const skip = entries.find(e => e.eventType === "worktree-skip");
+    assert.ok(skip, "worktree-skip event should be emitted");
+    assert.equal(skip!.data?.milestoneId, "M001");
+    assert.equal(skip!.data?.reason, "isolation-disabled");
+  });
+
+  test("enterMilestone emits worktree-create-failed on error", () => {
+    const s = makeSession({ basePath: tmp, originalBasePath: tmp });
+    const deps = makeDeps({
+      getAutoWorktreePath: () => null,
+      createAutoWorktree: () => { throw new Error("disk full"); },
+    });
+    const resolver = new WorktreeResolver(s, deps);
+
+    resolver.enterMilestone("M001", makeNotifyCtx());
+
+    const entries = readJournalEntries(tmp);
+    const failed = entries.find(e => e.eventType === "worktree-create-failed");
+    assert.ok(failed, "worktree-create-failed event should be emitted");
+    assert.equal(failed!.data?.milestoneId, "M001");
+    assert.equal(failed!.data?.error, "disk full");
+    assert.equal(failed!.data?.fallback, "project-root");
+  });
+
+  test("mergeAndExit emits worktree-merge-start", () => {
+    const s = makeSession({
+      basePath: join(tmp, "worktree"),
+      originalBasePath: tmp,
+    });
+    const deps = makeDeps({
+      isInAutoWorktree: () => true,
+      getIsolationMode: () => "worktree",
+    });
+    const resolver = new WorktreeResolver(s, deps);
+
+    resolver.mergeAndExit("M001", makeNotifyCtx());
+
+    const entries = readJournalEntries(tmp);
+    const start = entries.find(e => e.eventType === "worktree-merge-start");
+    assert.ok(start, "worktree-merge-start event should be emitted");
+    assert.equal(start!.data?.milestoneId, "M001");
+    assert.equal(start!.data?.mode, "worktree");
+  });
+
+  test("mergeAndExit emits worktree-merge-failed on error", () => {
+    const s = makeSession({
+      basePath: join(tmp, "worktree"),
+      originalBasePath: tmp,
+    });
+    const deps = makeDeps({
+      isInAutoWorktree: () => true,
+      getIsolationMode: () => "worktree",
+      mergeMilestoneToMain: () => { throw new Error("conflict in main"); },
+    });
+    const resolver = new WorktreeResolver(s, deps);
+
+    resolver.mergeAndExit("M001", makeNotifyCtx());
+
+    const entries = readJournalEntries(tmp);
+    const failed = entries.find(e => e.eventType === "worktree-merge-failed");
+    assert.ok(failed, "worktree-merge-failed event should be emitted");
+    assert.equal(failed!.data?.milestoneId, "M001");
+    assert.equal(failed!.data?.error, "conflict in main");
+  });
+
+  test("journal entries have valid flowId, seq, and ts fields", () => {
+    const s = makeSession({ basePath: tmp, originalBasePath: tmp });
+    const deps = makeDeps({ shouldUseWorktreeIsolation: () => false });
+    const resolver = new WorktreeResolver(s, deps);
+
+    resolver.enterMilestone("M001", makeNotifyCtx());
+
+    const entries = readJournalEntries(tmp);
+    assert.ok(entries.length > 0, "at least one entry should exist");
+    const entry = entries[0];
+    assert.ok(entry.flowId, "flowId should be set");
+    assert.ok(
+      /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/.test(entry.flowId),
+      "flowId should be a valid UUID",
+    );
+    assert.equal(entry.seq, 0);
+    assert.ok(entry.ts, "ts should be set");
+    assert.ok(!isNaN(Date.parse(entry.ts)), "ts should be a valid ISO date");
+  });
+});

package/src/resources/extensions/gsd/workflow-logger.ts

@@ -0,0 +1,193 @@
+// GSD Extension — Workflow Logger
+// Centralized warning/error accumulator for the workflow engine pipeline.
+// Captures structured entries that the auto-loop can drain after each unit
+// to surface root causes for stuck loops, silent degradation, and blocked writes.
+//
+// Stderr policy: every logWarning/logError call writes immediately to stderr
+// for terminal visibility. This is intentional — unlike debug-logger (which is
+// opt-in and zero-overhead when disabled), workflow-logger covers operational
+// warnings/errors that should always be visible. There is no disable flag.
+//
+// Singleton safety: _buffer is module-level and shared across all calls within
+// a process. The auto-loop must call _resetLogs() (or drainAndSummarize()) at
+// the start of each unit to prevent log bleed between units running in the same
+// Node process.
+
+// ─── Types ──────────────────────────────────────────────────────────────
+
+export type LogSeverity = "warn" | "error";
+
+export type LogComponent =
+  | "engine"        // WorkflowEngine afterCommand side effects
+  | "projection"    // Projection rendering
+  | "manifest"      // Manifest write
+  | "event-log"     // Event append
+  | "intercept"     // Write intercept / tool-call blocks
+  | "migration"     // Auto-migration from markdown
+  | "state"         // deriveState fallback/degradation
+  | "tool"          // Tool handler errors
+  | "compaction"    // Event compaction
+  | "reconcile";    // Worktree reconciliation
+
+export interface LogEntry {
+  ts: string;
+  severity: LogSeverity;
+  component: LogComponent;
+  message: string;
+  /** Optional structured context (file path, command name, etc.) */
+  context?: Record<string, string>;
+}
+
+// ─── Buffer ─────────────────────────────────────────────────────────────
+
+const MAX_BUFFER = 100;
+let _buffer: LogEntry[] = [];
+
+// ─── Public API ─────────────────────────────────────────────────────────
+
+/**
+ * Record a warning. Also writes to stderr for terminal visibility.
+ */
+export function logWarning(
+  component: LogComponent,
+  message: string,
+  context?: Record<string, string>,
+): void {
+  _push("warn", component, message, context);
+}
+
+/**
+ * Record an error. Also writes to stderr for terminal visibility.
+ */
+export function logError(
+  component: LogComponent,
+  message: string,
+  context?: Record<string, string>,
+): void {
+  _push("error", component, message, context);
+}
+
+/**
+ * Drain all accumulated entries and clear the buffer.
+ * Returns entries oldest-first.
+ *
+ * WARNING: Call summarizeLogs() or drainAndSummarize() BEFORE calling this
+ * if you need a summary — drainLogs() clears the buffer immediately.
+ */
+export function drainLogs(): LogEntry[] {
+  const entries = _buffer;
+  _buffer = [];
+  return entries;
+}
+
+/**
+ * Atomically summarize then drain — the safe way to consume logs.
+ * Use this in the auto-loop instead of calling summarizeLogs() + drainLogs()
+ * separately to avoid the ordering footgun.
+ */
+export function drainAndSummarize(): { logs: LogEntry[]; summary: string | null } {
+  const summary = summarizeLogs();
+  const logs = drainLogs();
+  return { logs, summary };
+}
+
+/**
+ * Peek at current entries without clearing.
+ */
+export function peekLogs(): readonly LogEntry[] {
+  return _buffer;
+}
+
+/**
+ * Returns true if the buffer contains any error-severity entries.
+ */
+export function hasErrors(): boolean {
+  return _buffer.some((e) => e.severity === "error");
+}
+
+/**
+ * Returns true if the buffer contains any warn-severity entries.
+ * Use hasAnyIssues() if you want to check for either severity.
+ */
+export function hasWarnings(): boolean {
+  return _buffer.some((e) => e.severity === "warn");
+}
+
+/**
+ * Returns true if the buffer contains any entries (warn or error).
+ */
+export function hasAnyIssues(): boolean {
+  return _buffer.length > 0;
+}
+
+/**
+ * Get a one-line summary of accumulated issues for stuck detection messages.
+ * Returns null if no entries.
+ *
+ * Must be called BEFORE drainLogs() — use drainAndSummarize() for safe ordering.
+ */
+export function summarizeLogs(): string | null {
+  if (_buffer.length === 0) return null;
+  const errors = _buffer.filter((e) => e.severity === "error");
+  const warns = _buffer.filter((e) => e.severity === "warn");
+
+  const parts: string[] = [];
+  if (errors.length > 0) {
+    parts.push(`${errors.length} error(s): ${errors.map((e) => e.message).join("; ")}`);
+  }
+  if (warns.length > 0) {
+    parts.push(`${warns.length} warning(s): ${warns.map((e) => e.message).join("; ")}`);
+  }
+  return parts.join(" | ");
+}
+
+/**
+ * Format entries for display (used by auto-loop post-unit notification).
+ * Note: context fields are not included in the formatted output.
+ */
+export function formatForNotification(entries: readonly LogEntry[]): string {
+  if (entries.length === 0) return "";
+  if (entries.length === 1) {
+    const e = entries[0];
+    return `[${e.component}] ${e.message}`;
+  }
+  return entries
+    .map((e) => `[${e.component}] ${e.message}`)
+    .join("\n");
+}
+
+/**
+ * Reset buffer. Call at the start of each auto-loop unit to prevent log bleed
+ * between units running in the same process. Also used in tests via _resetLogs().
+ */
+export function _resetLogs(): void {
+  _buffer = [];
+}
+
+// ─── Internal ───────────────────────────────────────────────────────────
+
+function _push(
+  severity: LogSeverity,
+  component: LogComponent,
+  message: string,
+  context?: Record<string, string>,
+): void {
+  const entry: LogEntry = {
+    ts: new Date().toISOString(),
+    severity,
+    component,
+    message,
+    ...(context ? { context } : {}),
+  };
+
+  // Always forward to stderr so terminal watchers see it (see module header for policy)
+  const prefix = severity === "error" ? "ERROR" : "WARN";
+  const ctxStr = context ? ` ${JSON.stringify(context)}` : "";
+  process.stderr.write(`[gsd:${component}] ${prefix}: ${message}${ctxStr}\n`);
+
+  // Buffer for auto-loop to drain
+  _buffer.push(entry);
+  if (_buffer.length > MAX_BUFFER) {
+    _buffer.shift();
+  }
+}