@opengsd/gsd-pi 1.3.0-dev.eed73bea → 1.4.0-dev.5fc22c6f

package/src/resources/extensions/gsd/tests/state-reconciliation-drift.test.ts

@@ -42,6 +42,7 @@ import {
   type ReconciliationDeps,
 } from "../state-reconciliation.ts";
 import { classifyFailure } from "../recovery-classification.ts";
+import { handlerPhaseIndex, RECONCILIATION_REPAIR_PHASES } from "../state-reconciliation/registry.ts";
 import { staleRenderHandler } from "../state-reconciliation/drift/stale-render.ts";
 import type { GSDState } from "../types.ts";
 
@@ -160,6 +161,29 @@ test("ADR-017 (#5700): repair failure throws ReconciliationFailedError with shap
   );
 });
 
+test("ADR-017 (#5700): custom registry handlers outside built-in phases are repaired", async () => {
+  const drift = { kind: "custom-drift", id: "D001" } as unknown as DriftRecord;
+  let repaired = false;
+  const handler = {
+    kind: "custom-drift",
+    detect: () => (repaired ? [] : [drift]),
+    repair: () => {
+      repaired = true;
+    },
+  } as unknown as DriftHandler;
+
+  const result = await reconcileBeforeDispatch("/project", {
+    invalidateStateCache: () => {},
+    deriveState: async () => makeState(),
+    registry: [handler],
+  });
+
+  assert.equal(result.ok, true);
+  assert.equal(repaired, true);
+  assert.equal(result.repaired.length, 1);
+  assert.equal(result.repaired[0]?.kind, "custom-drift");
+});
+
 test("ADR-017 (#5700): a detector failure degrades to a blocker without aborting other handlers", async () => {
   // A single detector throwing (e.g. a transient file read error) must NOT
   // abort the whole cycle and hide every later handler's drift. It is collected
@@ -772,6 +796,51 @@ test("#1003: stale-render plan repair switches back from an open wrong DB", asyn
   assert.equal(getSliceTasks("M001", "S01").length, 1, "repair should leave the project DB active");
 });
 
+test("#1034: validation-blocked milestone summary drift returns blocker instead of exhausting repair passes", async () => {
+  const drift: Extract<DriftRecord, { kind: "stale-render" }> = {
+    kind: "stale-render",
+    renderPath: "/repo/.gsd/milestones/M001/M001-SUMMARY.md",
+    reason: "M001 is complete with summary in DB but SUMMARY.md missing on disk",
+  };
+  let repairCalled = false;
+  const handler: DriftHandler<Extract<DriftRecord, { kind: "stale-render" }>> = {
+    kind: "stale-render",
+    detect: () => [drift],
+    blocker: staleRenderHandler.blocker!,
+    repair: () => {
+      repairCalled = true;
+    },
+  };
+
+  const validationBlocker = [
+    "Milestone M001 is blocked because milestone validation returned needs-attention.",
+    "Fix options:",
+    "1. Review the validation details: `/gsd status`",
+  ].join("\n");
+
+  const result = await reconcileBeforeDispatch("/repo", {
+    invalidateStateCache: () => {},
+    deriveState: async () =>
+      makeState({
+        phase: "blocked",
+        blockers: [validationBlocker],
+        nextAction: "Resolve M001 validation attention before proceeding.",
+      }),
+    registry: [handler],
+  });
+
+  assert.equal(result.ok, true);
+  assert.equal(repairCalled, false, "validation-blocked milestone summary drift should not attempt repair");
+  assert.ok(
+    result.blockers.some((blocker) => blocker.includes("milestone validation returned needs-attention")),
+    "validation blocker should be returned to the caller",
+  );
+  assert.ok(
+    result.blockers.some((blocker) => blocker.includes("Stale milestone summary render")),
+    "stale-render blocker should explain why repair did not run",
+  );
+});
+
 test("ADR-017 (#5702): stale-render detector reason strings match repair contract", (t) => {
   t.skip("TODO(flat-phase): stale-render detection temporarily disabled during layout transition"); return;
   const base = mkdtempSync(join(tmpdir(), "gsd-adr017-render-reasons-"));
@@ -1887,3 +1956,49 @@ test("ADR-017 (#5700): cascading drift triggers second pass within cap", async (
   assert.equal(result.repaired.length, 2, "both passes' repairs collected");
   assert.equal(repaired.length, 2);
 });
+
+test("deriveState is pure: stale sketch healed only via reconcileBeforeDispatch", async (t) => {
+  const base = makeFixtureBase();
+  t.after(() => cleanup(base));
+
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Test", status: "active" });
+  insertSlice({
+    id: "S02",
+    milestoneId: "M001",
+    title: "Feature",
+    status: "pending",
+    risk: "medium",
+    depends: [],
+    demo: "S02 demo.",
+    sequence: 1,
+    isSketch: true,
+    sketchScope: "limited",
+  });
+  writeFileSync(
+    join(base, ".gsd", "phases", "01-test", "01-02-PLAN.md"),
+    "# S02 Plan\n",
+  );
+
+  const { deriveState } = await import("../state.ts");
+  invalidateStateCache();
+
+  const beforeReconcile = await deriveState(base);
+  assert.equal(beforeReconcile.phase, "refining", "derive alone must not heal stale sketch flag");
+  assert.equal(getSlice("M001", "S02")?.is_sketch, 1, "DB flag unchanged before reconcile");
+
+  const result = await reconcileBeforeDispatch(base);
+  assert.equal(result.ok, true);
+  assert.equal(getSlice("M001", "S02")?.is_sketch, 0, "reconcile clears sketch flag");
+
+  invalidateStateCache();
+  const afterReconcile = await deriveState(base);
+  assert.notEqual(afterReconcile.phase, "refining", "derive after reconcile advances past sketch gate");
+});
+
+test("reconciliation repair phases: external edits precede re-project handlers", () => {
+  assert.equal(RECONCILIATION_REPAIR_PHASES.length, 3);
+  assert.ok(handlerPhaseIndex("external-markdown-edit") < handlerPhaseIndex("stale-render"));
+  assert.ok(handlerPhaseIndex("external-planning-edit") < handlerPhaseIndex("roadmap-divergence"));
+  assert.ok(handlerPhaseIndex("stale-sketch-flag") < handlerPhaseIndex("stale-render"));
+});

package/src/resources/extensions/gsd/tests/status-per-repo.test.ts

@@ -0,0 +1,94 @@
+/**
+ * status-per-repo.test.ts — `/gsd status` per-repository git-health block (#818).
+ *
+ * Covers the parent-workspace addition to formatTextStatus:
+ *   - parent mode with child repos → "Repositories:" section listing each
+ *   - dirty vs clean markers
+ *   - single-repo (project-mode) project → no Repositories section
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { execFileSync } from "node:child_process";
+
+import { formatTextStatus } from "../commands/handlers/core.ts";
+import type { GSDState } from "../types.ts";
+
+function gitInit(cwd: string): void {
+  execFileSync("git", ["init"], { cwd, stdio: "ignore" });
+}
+
+function makeBaseState(): GSDState {
+  return {
+    activeMilestone: null,
+    activeSlice: null,
+    activeTask: null,
+    phase: "planning",
+    recentDecisions: [],
+    blockers: [],
+    nextAction: "None",
+    registry: [],
+  };
+}
+
+function writeParentPrefs(base: string, repos: Record<string, { path: string; role?: string }>): void {
+  const repoLines = Object.entries(repos)
+    .map(([id, cfg]) => `    ${id}:\n      path: ${cfg.path}${cfg.role ? `\n      role: ${cfg.role}` : ""}`)
+    .join("\n");
+  writeFileSync(
+    join(base, ".gsd", "PREFERENCES.md"),
+    `---\nversion: 1\nworkspace:\n  mode: parent\n  repositories:\n${repoLines}\n---\n`,
+    "utf-8",
+  );
+}
+
+test("formatTextStatus shows a Repositories section for a clean parent workspace", () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-status-repo-clean-"));
+  try {
+    mkdirSync(join(base, ".gsd"), { recursive: true });
+    gitInit(base);
+    mkdirSync(join(base, "frontend"), { recursive: true });
+    gitInit(join(base, "frontend"));
+    writeParentPrefs(base, { frontend: { path: "frontend", role: "web UI" } });
+
+    const out = formatTextStatus(makeBaseState(), base);
+    assert.match(out, /Repositories:/);
+    assert.match(out, /✓ frontend — web UI \(clean\)/);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("formatTextStatus marks a dirty child repo with ✗", () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-status-repo-dirty-"));
+  try {
+    mkdirSync(join(base, ".gsd"), { recursive: true });
+    gitInit(base);
+    mkdirSync(join(base, "backend"), { recursive: true });
+    gitInit(join(base, "backend"));
+    writeParentPrefs(base, { backend: { path: "backend" } });
+    // Make the backend repo dirty.
+    writeFileSync(join(base, "backend", "README.md"), "# dirty\n", "utf-8");
+
+    const out = formatTextStatus(makeBaseState(), base);
+    assert.match(out, /✗ backend \(uncommitted changes\)/);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("formatTextStatus omits the Repositories section for single-repo projects", () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-status-repo-single-"));
+  try {
+    mkdirSync(join(base, ".gsd"), { recursive: true });
+    gitInit(base);
+    // No workspace config → project mode (default).
+    const out = formatTextStatus(makeBaseState(), base);
+    assert.doesNotMatch(out, /Repositories:/);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/token-tool-gating.test.ts

@@ -552,6 +552,41 @@ test("discuss-milestone dispatch keeps required headless milestone tools after t
   assert.ok(!activeTools.includes("gsd_complete_milestone"));
 });
 
+test("#1157: validate-milestone dispatch surface removes generic write and bash tools", () => {
+  const result = buildMinimalAutoGsdToolSet([
+    "ask_user_questions",
+    "bash",
+    "bg_shell",
+    "edit",
+    "find",
+    "glob",
+    "grep",
+    "ls",
+    "read",
+    "subagent",
+    "write",
+    "gsd_exec",
+    "gsd_exec_search",
+    "gsd_resume",
+    "gsd_milestone_status",
+    "gsd_validate_milestone",
+    "gsd_reassess_roadmap",
+  ], "validate-milestone");
+
+  assert.ok(result.includes("read"));
+  assert.ok(result.includes("find"));
+  assert.ok(result.includes("subagent"));
+  assert.ok(result.includes("gsd_validate_milestone"));
+  assert.ok(result.includes("gsd_milestone_status"));
+  assert.ok(result.includes("gsd_exec"));
+  assert.ok(result.includes("gsd_reassess_roadmap"));
+  assert.ok(!result.includes("bash"));
+  assert.ok(!result.includes("bg_shell"));
+  assert.ok(!result.includes("write"));
+  assert.ok(!result.includes("edit"));
+  assert.ok(!result.includes("ask_user_questions"));
+});
+
 test("scopeGsdWorkflowToolsForDispatch applies and restores per-unit skill visibility", () => {
   const calls: Array<{ kind: "tools" | "skills"; value: string[] | undefined }> = [];
   let activeTools = [

package/src/resources/extensions/gsd/tests/tool-call-loop-guard.test.ts

@@ -7,6 +7,7 @@ import { test } from 'node:test';
 import assert from 'node:assert/strict';
 import {
   checkToolCallLoop,
+  recordToolCallLoopMutation,
   resetToolCallLoopGuard,
   disableToolCallLoopGuard,
   getToolCallLoopCount,
@@ -223,6 +224,62 @@ console.log('\n── Loop guard: repeatable tools get the higher cap (#783) ─
   assert.ok(blocked.reason!.includes('cap 15'), 'reason should mention the repeatable cap');
 }
 
+// ═══════════════════════════════════════════════════════════════════════════
+// Mutation progress decays per-tool counts (#1092)
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n── Loop guard: mutation progress decays per-tool counts (#1092) ──');
+
+{
+  resetToolCallLoopGuard();
+
+  // bash is called more than the repeatable cap, but each count is separated
+  // by a successful file mutation. Guard 2 should treat that as progress and
+  // avoid blocking the progressing unit.
+  for (let i = 1; i <= 20; i++) {
+    const result = checkToolCallLoop('bash', { command: `echo ${i}` });
+    assert.ok(result.block === false, `bash call ${i} after mutation progress should be allowed`);
+    assert.deepStrictEqual(getToolCallCountForTool('bash'), 1, `bash count should decay before call ${i}`);
+
+    const mutationTool = i % 2 === 0 ? 'write' : 'edit';
+    const mutation = checkToolCallLoop(mutationTool, {
+      path: `file-${i}.ts`,
+      content: `content ${i}`,
+    });
+    assert.ok(mutation.block === false, `${mutationTool} mutation ${i} should be allowed`);
+    recordToolCallLoopMutation(mutationTool);
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Distinct read-only navigation calls are context gathering, not repeated-tool loops.
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n── Loop guard: distinct read-only navigation calls are not capped by per-tool count ──');
+
+{
+  const exemptTools = ['find', 'glob', 'grep', 'ls', 'read', 'search_and_read'];
+
+  for (const toolName of exemptTools) {
+    resetToolCallLoopGuard();
+
+    for (let i = 1; i <= 20; i++) {
+      const result = checkToolCallLoop(toolName, { path: `file-${i}.ts` });
+      assert.ok(result.block === false, `distinct ${toolName} call ${i} should be allowed`);
+    }
+
+    resetToolCallLoopGuard();
+    for (let i = 1; i <= 4; i++) {
+      const result = checkToolCallLoop(toolName, { path: 'same-file.ts' });
+      assert.ok(result.block === false, `identical ${toolName} call ${i} should be allowed`);
+    }
+
+    const blocked = checkToolCallLoop(toolName, { path: 'same-file.ts' });
+    assert.ok(blocked.block === true, `5th identical ${toolName} call should still be blocked`);
+    assert.ok(blocked.reason?.includes('identical args'), `${toolName} loops should be caught by Guard 1`);
+  }
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 // Per-tool counts are independent per tool and reset together
 // ═══════════════════════════════════════════════════════════════════════════
@@ -245,3 +302,149 @@ console.log('\n── Loop guard: per-tool counts are independent and reset toge
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
+// Non-exempt repeatable tools from core-session-tools.ts get the higher cap.
+// Read-only navigation tools are exempted earlier; mutating/execution repeatable
+// tools (e.g. gsd_exec) must still trip the per-tool cap.
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n── Loop guard: non-exempt repeatable tools get high cap ──');
+
+{
+  for (const toolName of ['bg_shell', 'gsd_exec', 'write']) {
+    resetToolCallLoopGuard();
+
+    // Should allow up to 15 varied calls without blocking.
+    for (let i = 1; i <= 15; i++) {
+      const result = checkToolCallLoop(toolName, { arg: `v${i}` });
+      assert.ok(result.block === false, `${toolName} call ${i} (varied args) should be allowed`);
+    }
+    // 16th call with varied args must be blocked by the per-tool repeatable cap.
+    const blocked = checkToolCallLoop(toolName, { arg: 'v16' });
+    assert.ok(blocked.block === true, `${toolName}: 16th call must be blocked by repeatable cap`);
+    assert.ok(blocked.reason?.includes('cap 15'), `${toolName}: reason must mention cap 15`);
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Non-repeatable tools excluded from INHERENTLY_REPEATABLE_TOOL_SET use the
+// default cap (6), not the repeatable cap (15).
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n── Loop guard: ToolSearch (excluded from repeatable set) hits default cap ──');
+
+{
+  // ToolSearch is in MINIMAL_AUTO_BASE but explicitly excluded from repeatable.
+  // It should hit the default cap of 6, not 15.
+  resetToolCallLoopGuard();
+  for (let i = 1; i <= 6; i++) {
+    const result = checkToolCallLoop('ToolSearch', { query: `q${i}` });
+    assert.ok(result.block === false, `ToolSearch call ${i} should be allowed`);
+  }
+  const blocked = checkToolCallLoop('ToolSearch', { query: 'q7' });
+  assert.ok(blocked.block === true, 'ToolSearch: 7th varied call must be blocked by default cap');
+  assert.ok(!blocked.reason?.includes('cap 15'), 'ToolSearch must NOT use the repeatable cap');
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Block reasons instruct the model to stop tooling this turn
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n── Loop guard: block reasons tell model to respond in text ──');
+
+{
+  resetToolCallLoopGuard();
+
+  for (let i = 0; i < 4; i++) {
+    checkToolCallLoop('web_search', { query: 'same query' });
+  }
+  const identicalBlocked = checkToolCallLoop('web_search', { query: 'same query' });
+  assert.ok(identicalBlocked.block === true, 'identical-args guard should block');
+  assert.ok(
+    identicalBlocked.reason!.includes('respond to the user in text'),
+    'identical-args reason should tell the model to stop tooling',
+  );
+  assert.ok(
+    !identicalBlocked.reason!.includes('Try a different approach'),
+    'identical-args reason should not suggest retrying another tool',
+  );
+
+  resetToolCallLoopGuard();
+  for (let i = 0; i < 6; i++) {
+    checkToolCallLoop('gsd_complete_milestone', { milestone: `M${i}` });
+  }
+  const perToolBlocked = checkToolCallLoop('gsd_complete_milestone', { milestone: 'M7' });
+  assert.ok(perToolBlocked.block === true, 'per-tool guard should block');
+  assert.ok(
+    perToolBlocked.reason!.includes('respond to the user in text'),
+    'per-tool reason should tell the model to stop tooling',
+  );
+  assert.ok(
+    perToolBlocked.reason!.includes('Do not retry this tool'),
+    'per-tool reason should forbid retrying the blocked tool',
+  );
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Distinct-arg browser-automation calls are a legitimate UAT, not a loop (#1120)
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n── Loop guard: distinct-arg browser automation calls are not capped by per-tool count (#1120) ──');
+
+{
+  // A browser-backed UAT legitimately calls one browser verb many times with
+  // DIFFERENT arguments (read a validation message, count staged edits, inspect
+  // a control card, …). Guard 1's identical-signature streak never trips because
+  // the args vary; Guard 2's arg-independent per-tool cap must NOT block it.
+  for (const toolName of ['browser_evaluate', 'browser_act', 'browser_find']) {
+    resetToolCallLoopGuard();
+    for (let i = 1; i <= 12; i++) {
+      const result = checkToolCallLoop(toolName, { script: `step ${i}` });
+      assert.ok(result.block === false, `distinct ${toolName} call ${i} should be allowed`);
+    }
+  }
+
+  // MCP-prefixed browser tools canonicalize to `browser_*` and are exempt too.
+  resetToolCallLoopGuard();
+  for (let i = 1; i <= 12; i++) {
+    const result = checkToolCallLoop('mcp__agent-browser__browser_evaluate', { script: `step ${i}` });
+    assert.ok(result.block === false, `distinct MCP-prefixed browser_evaluate call ${i} should be allowed`);
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Identical-arg browser loops are STILL caught by Guard 1 (#1120)
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n── Loop guard: identical-arg browser loops are still caught by Guard 1 (#1120) ──');
+
+{
+  resetToolCallLoopGuard();
+  for (let i = 1; i <= 4; i++) {
+    const result = checkToolCallLoop('browser_evaluate', { script: 'document.title' });
+    assert.ok(result.block === false, `identical browser_evaluate call ${i} should be allowed`);
+  }
+  const blocked = checkToolCallLoop('browser_evaluate', { script: 'document.title' });
+  assert.ok(blocked.block === true, '5th identical browser_evaluate call should be blocked by Guard 1');
+  assert.ok(blocked.reason?.includes('identical args'), 'identical browser loops should be caught by Guard 1, not Guard 2');
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// The browser exemption must NOT widen to other non-exempt tools (#1120)
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n── Loop guard: browser exemption does not widen to other tools (#1120) ──');
+
+{
+  // Negative invariant: an arbitrary non-exempt, non-browser tool called past
+  // the default cap with varied args must still be blocked by Guard 2.
+  resetToolCallLoopGuard();
+  for (let i = 1; i <= 6; i++) {
+    const result = checkToolCallLoop('some_workflow_tool', { arg: `v${i}` });
+    assert.ok(result.block === false, `non-exempt tool call ${i} should be allowed`);
+  }
+  const blocked = checkToolCallLoop('some_workflow_tool', { arg: 'v7' });
+  assert.ok(blocked.block === true, '7th varied-arg non-exempt call must still trip Guard 2');
+  assert.ok(blocked.reason?.includes('repeated tool'), 'non-exempt overflow should be caught by Guard 2');
+}
+
+// ═══════════════════════════════════════════════════════════════════════════

package/src/resources/extensions/gsd/tests/tool-param-optionality.test.ts

@@ -385,14 +385,17 @@ test("gsd_plan_slice — enrichment fields are optional", () => {
 
   const required = new Set(getRequiredProps(tool));
 
-  // Core fields
-  const coreRequired = ["milestoneId", "sliceId", "goal", "tasks"];
+  // Core fields. `tasks` is intentionally NOT here: incremental planning
+  // (#1027) lets gsd_plan_slice persist slice metadata only, then add tasks
+  // one at a time via gsd_plan_task, so tasks must be optional.
+  const coreRequired = ["milestoneId", "sliceId", "goal"];
   for (const field of coreRequired) {
     assert.ok(required.has(field), `core field "${field}" must be required`);
   }
 
-  // Enrichment fields
+  // Enrichment fields (plus tasks, optional for incremental planning).
   const enrichmentFields = [
+    "tasks",
     "successCriteria",
     "proofLevel",
     "integrationClosure",

package/src/resources/extensions/gsd/tests/undo.test.ts

@@ -10,6 +10,7 @@ import {
   handleUndo,
   handleUndoTask,
   handleResetSlice,
+  parseActivityLogFilename,
   uncheckTaskInPlan,
 } from "../undo.ts";
 import {
@@ -67,6 +68,37 @@ test("handleUndo without --force only warns and leaves completed units intact",
   }
 });
 
+test("handleUndo execute-task with --force reopens the task row and re-renders plan", async () => {
+  const base = makeTempDir("gsd-undo-execute-task");
+  try {
+    setupTaskFixture(base);
+    mkdirSync(join(base, ".gsd", "activity"), { recursive: true });
+    writeFileSync(
+      join(base, ".gsd", "activity", "001-execute-task-M001-S01-T01.jsonl"),
+      "",
+      "utf-8",
+    );
+
+    const { notifications, ctx } = makeCtx();
+    await handleUndo("--force", ctx, {} as any, base);
+
+    const task = getTask("M001", "S01", "T01");
+    assert.equal(task?.status, "pending");
+
+    const planContent = readFileSync(
+      join(base, ".gsd", "phases", "01-test", "01-01-PLAN.md"),
+      "utf-8",
+    );
+    assert.match(planContent, /\[ \] \*\*T01\*\*:/);
+
+    assert.equal(notifications[0]?.level, "success");
+    assert.match(notifications[0]?.message ?? "", /Unchecked task in PLAN/);
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
 test("uncheckTaskInPlan flips a checked task back to unchecked", () => {
   const base = makeTempDir("gsd-undo-plan");
   try {
@@ -154,6 +186,48 @@ test("extractCommitShas ignores malformed commit tokens", () => {
   assert.deepEqual(extractCommitShas(content), ["1234567"]);
 });
 
+test("parseActivityLogFilename splits hyphenated unit types from their IDs", () => {
+  // Task-level: unit type and ID both contain hyphens.
+  assert.deepEqual(parseActivityLogFilename("001-execute-task-M001-S01-T01.jsonl"), {
+    unitType: "execute-task",
+    unitId: "M001-S01-T01",
+  });
+  // Variant must win over its shorter prefix ("execute-task").
+  assert.deepEqual(parseActivityLogFilename("002-execute-task-simple-M001-S02-T03.jsonl"), {
+    unitType: "execute-task-simple",
+    unitId: "M001-S02-T03",
+  });
+  // Milestone- and slice-shaped IDs.
+  assert.deepEqual(parseActivityLogFilename("003-research-milestone-M001.jsonl"), {
+    unitType: "research-milestone",
+    unitId: "M001",
+  });
+  assert.deepEqual(parseActivityLogFilename("004-plan-slice-M001-S01.jsonl"), {
+    unitType: "plan-slice",
+    unitId: "M001-S01",
+  });
+});
+
+test("parseActivityLogFilename accepts non-milestone-shaped unit IDs", () => {
+  // Regression (#1057): project-level units use IDs that do not start with
+  // "M<digit>". A milestone-shaped regex made /gsd undo bail out with
+  // "could not parse latest activity log" when one of these was most recent.
+  assert.deepEqual(parseActivityLogFilename("005-discuss-project-PROJECT.jsonl"), {
+    unitType: "discuss-project",
+    unitId: "PROJECT",
+  });
+  assert.deepEqual(parseActivityLogFilename("006-workflow-preferences-WORKFLOW-PREFS.jsonl"), {
+    unitType: "workflow-preferences",
+    unitId: "WORKFLOW-PREFS",
+  });
+});
+
+test("parseActivityLogFilename returns null for unrecognized names", () => {
+  assert.equal(parseActivityLogFilename("007-not-a-real-unit-M001.jsonl"), null);
+  assert.equal(parseActivityLogFilename("no-sequence-prefix.jsonl"), null);
+  assert.equal(parseActivityLogFilename("001-execute-task-M001-S01-T01.txt"), null);
+});
+
 // ─── handleUndoTask tests ────────────────────────────────────────────────────
 
 function makeCtx(): { notifications: Array<{ message: string; level: string }>; ctx: any } {