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

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/tools/complete-milestone.ts

@@ -31,6 +31,7 @@ export interface CompleteMilestoneParams {
   lessonsLearned: string[];
   followUps: string;
   deviations: string;
+  verificationPassed: boolean;
 }
 
 export interface CompleteMilestoneResult {
@@ -108,6 +109,11 @@ export async function handleCompleteMilestone(
     return { error: "title is required and must be a non-empty string" };
   }
 
+  // ── Verify that verification passed ─────────────────────────────────────
+  if (params.verificationPassed !== true) {
+    return { error: "verification did not pass — milestone completion blocked. verificationPassed must be explicitly set to true after all verification steps succeed" };
+  }
+
   // ── Verify all slices are complete ───────────────────────────────────────
   const slices = getMilestoneSlices(params.milestoneId);
   if (slices.length === 0) {