@opengsd/gsd-pi 1.3.0-dev.72e3af2a → 1.3.0-dev.965d1788

package/src/resources/extensions/gsd/tests/verification-retry-policy.test.ts

@@ -11,6 +11,8 @@ import {
   verificationRetryKey,
   VERIFICATION_RETRY_MAX_DELAY_MS,
 } from "../auto/verification-retry-policy.ts";
+import { formatFailureContext, formatFailureSignature } from "../verification-gate.ts";
+import type { VerificationResult } from "../types.ts";
 
 test("verificationRetryDelayMs uses exponential backoff with cap", () => {
   assert.deepEqual(verificationRetryDelayMs(1, () => 0.5), {
@@ -31,9 +33,22 @@ test("verificationRetryDelayMs uses exponential backoff with cap", () => {
   });
 });
 
-test("decideVerificationRetry pauses on duplicate failure context", () => {
+test("decideVerificationRetry pauses on repeated failure context across attempts", () => {
   const failureContext = "lint failed\n";
-  const failureHash = hashVerificationFailureContext(failureContext);
+  const firstDecision = decideVerificationRetry({
+    unitType: "execute-task",
+    retryInfo: {
+      unitId: "M001/S01/T01",
+      failureContext,
+      attempt: 1,
+    },
+    previousFailureHash: undefined,
+    random: () => 0.5,
+  });
+
+  assert.equal(firstDecision.action, "delay");
+  assert.equal(firstDecision.failureHash, hashVerificationFailureContext(failureContext));
+
   const decision = decideVerificationRetry({
     unitType: "execute-task",
     retryInfo: {
@@ -41,7 +56,7 @@ test("decideVerificationRetry pauses on duplicate failure context", () => {
       failureContext,
       attempt: 2,
     },
-    previousFailureHash: failureHash,
+    previousFailureHash: firstDecision.failureHash,
     random: () => 0.5,
   });
 
@@ -49,7 +64,7 @@ test("decideVerificationRetry pauses on duplicate failure context", () => {
     action: "pause",
     reason: "duplicate-failure-context",
     key: verificationRetryKey("execute-task", "M001/S01/T01"),
-    failureHash,
+    failureHash: firstDecision.failureHash,
   });
 });
 
@@ -71,6 +86,56 @@ test("decideVerificationRetry delays changed failure context", () => {
   assert.equal(decision.baseDelayMs, 4_000);
 });
 
+test("decideVerificationRetry pauses duplicate host-check failures with volatile stderr", () => {
+  const makeResult = (stderr: string): VerificationResult => ({
+    passed: false,
+    discoverySource: "package-json",
+    timestamp: Date.now(),
+    checks: [
+      {
+        command: "npm test",
+        exitCode: 1,
+        stdout: "",
+        stderr,
+        durationMs: 100,
+      },
+    ],
+  });
+  const first = makeResult("failed after 120ms in /tmp/gsd-a worker pid 101");
+  const second = makeResult("failed after 133ms in /tmp/gsd-b worker pid 202");
+  const firstContext = formatFailureContext(first);
+  const secondContext = formatFailureContext(second);
+
+  assert.notEqual(
+    hashVerificationFailureContext(firstContext),
+    hashVerificationFailureContext(secondContext),
+  );
+
+  const signature = formatFailureSignature(first);
+  assert.equal(signature, "npm test#1");
+  assert.equal(formatFailureSignature(second), signature);
+
+  const failureHash = hashVerificationFailureContext(signature);
+  const decision = decideVerificationRetry({
+    unitType: "execute-task",
+    retryInfo: {
+      unitId: "M001/S01/T01",
+      failureContext: secondContext,
+      signature: formatFailureSignature(second),
+      attempt: 2,
+    },
+    previousFailureHash: failureHash,
+    random: () => 0.5,
+  });
+
+  assert.deepEqual(decision, {
+    action: "pause",
+    reason: "duplicate-failure-context",
+    key: verificationRetryKey("execute-task", "M001/S01/T01"),
+    failureHash,
+  });
+});
+
 test("decideVerificationRetry pauses when retry context is missing", () => {
   assert.deepEqual(
     decideVerificationRetry({

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

@@ -380,6 +380,60 @@ test('workflow-manifest: bootstrapFromManifest preserves target_repositories', (
   }
 });
 
+test('workflow-manifest: bootstrapFromManifest does not truncate projections when artifact content is empty', () => {
+  const base = tempDir();
+  openDatabase(tempDbPath(base));
+  try {
+    insertMilestone({ id: 'M001', title: 'Projection Milestone' });
+    insertArtifact({
+      path: '.gsd/milestones/M001/M001-PLAN.md',
+      artifact_type: 'PLAN',
+      milestone_id: 'M001',
+      slice_id: null,
+      task_id: null,
+      full_content: '# Manifest Plan',
+    });
+    insertArtifact({
+      path: '.gsd/milestones/M001/M001-VALIDATION.md',
+      artifact_type: 'VALIDATION',
+      milestone_id: 'M001',
+      slice_id: null,
+      task_id: null,
+      full_content: '# Manifest Validation',
+    });
+    writeManifest(base);
+
+    const planPath = path.join(base, '.gsd', 'milestones', 'M001', 'M001-PLAN.md');
+    const validationPath = path.join(base, '.gsd', 'milestones', 'M001', 'M001-VALIDATION.md');
+    fs.mkdirSync(path.dirname(planPath), { recursive: true });
+    fs.writeFileSync(planPath, '# Existing Plan\n\nKeep this.');
+    fs.writeFileSync(validationPath, '# Existing Validation\n\nKeep this.');
+
+    const manifestPath = path.join(base, '.gsd', 'state-manifest.json');
+    const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8')) as Record<string, unknown>;
+    const artifacts = manifest['artifacts'] as Array<Record<string, unknown>>;
+    const emptyArtifact = artifacts.find((r) => r['path'] === '.gsd/milestones/M001/M001-PLAN.md');
+    const absentArtifact = artifacts.find((r) => r['path'] === '.gsd/milestones/M001/M001-VALIDATION.md');
+    assert.ok(emptyArtifact !== undefined);
+    assert.ok(absentArtifact !== undefined);
+    emptyArtifact['full_content'] = '';
+    delete absentArtifact['full_content'];
+    fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+    closeDatabase();
+
+    const newDbPath = path.join(base, 'new.db');
+    openDatabase(newDbPath);
+    const restored = bootstrapFromManifest(base);
+    assert.strictEqual(restored, true);
+
+    assert.strictEqual(fs.readFileSync(planPath, 'utf-8'), '# Existing Plan\n\nKeep this.');
+    assert.strictEqual(fs.readFileSync(validationPath, 'utf-8'), '# Existing Validation\n\nKeep this.');
+  } finally {
+    closeDatabase();
+    cleanupDir(base);
+  }
+});
+
 test('workflow-manifest: bootstrapFromManifest preserves optional rows from old manifests', () => {
   const base = tempDir();
   openDatabase(tempDbPath(base));

package/src/resources/extensions/gsd/tools/complete-milestone.ts

@@ -23,7 +23,7 @@ import {
 } from "../gsd-db.js";
 import { gsdProjectionRoot, clearPathCache, relMilestoneFile } from "../paths.js";
 import { resolveCanonicalMilestoneRoot } from "../worktree-manager.js";
-import { isClosedStatus } from "../status-guards.js";
+import { isClosedStatus, isDeferredStatus } from "../status-guards.js";
 import { saveFile, clearParseCache } from "../files.js";
 import { invalidateStateCache } from "../state.js";
 import { stripIdPrefix } from "../workflow-projections.js";
@@ -180,7 +180,7 @@ export async function handleCompleteMilestone(
       return;
     }
 
-    const incompleteSlices = slices.filter(s => !isClosedStatus(s.status));
+    const incompleteSlices = slices.filter(s => !isClosedStatus(s.status) && !isDeferredStatus(s.status));
     if (incompleteSlices.length > 0) {
       const incompleteIds = incompleteSlices.map(s => `${s.id} (status: ${s.status})`).join(", ");
       guardError = `incomplete slices: ${incompleteIds}`;
@@ -189,6 +189,7 @@ export async function handleCompleteMilestone(
 
     // Deep check: verify all tasks in all slices are complete
     for (const slice of slices) {
+      if (isDeferredStatus(slice.status)) continue;
       const tasks = getSliceTasks(params.milestoneId, slice.id);
       const incompleteTasks = tasks.filter(t => !isClosedStatus(t.status));
       if (incompleteTasks.length > 0) {

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

@@ -15,6 +15,7 @@ import { gsdRoot, resolveTasksDir, resolveSlicePath, resolveSliceFile, resolveTa
 import { sendDesktopNotification } from "./notifications.js";
 import { getTask, getSlice, getSliceTasks, updateTaskStatus, resetSliceCascade } from "./gsd-db.js";
 import { renderPlanCheckboxes, renderRoadmapCheckboxes } from "./markdown-renderer.js";
+import { UNIT_REGISTRY } from "./unit-registry.js";
 
 /**
  * Undo the last completed unit: revert git commits,
@@ -42,16 +43,20 @@ export async function handleUndo(args: string, ctx: ExtensionCommandContext, _pi
     return;
   }
 
-  // Extract unit type and ID from the most recent activity log filename
-  // Format: <seq>-<unitType>-<unitId>.jsonl
-  const match = files[0].match(/^\d+-(.+?)-(.+)\.jsonl$/);
-  if (!match) {
+  // Extract unit type and ID from the most recent activity log filename.
+  // Both the unit type and the unit ID may contain hyphens, so anchor on the
+  // known unit-type vocabulary instead of guessing the unit-ID shape: a regex
+  // tuned to milestone-shaped IDs rejects project-level units whose IDs are
+  // symbolic (e.g. discuss-project uses PROJECT, workflow-preferences uses
+  // WORKFLOW-PREFS).
+  const parsed = parseActivityLogFilename(files[0]);
+  if (!parsed) {
     ctx.ui.notify("Nothing to undo — could not parse latest activity log.", "warning");
     return;
   }
 
-  const unitType = match[1];
-  const unitId = match[2].replace(/-/g, "/");
+  const unitType = parsed.unitType;
+  const unitId = parsed.unitId.replace(/-/g, "/");
 
   if (!force) {
     ctx.ui.notify(
@@ -100,6 +105,11 @@ export async function handleUndo(args: string, ctx: ExtensionCommandContext, _pi
   if (unitType === "execute-task" && task !== undefined && slice !== undefined) {
     const [mid, sid, tid] = [milestone, slice, task];
     planUpdated = uncheckTaskInPlan(basePath, mid, sid, tid);
+    if (getTask(mid, sid, tid)) {
+      updateTaskStatus(mid, sid, tid, "pending");
+      await renderPlanCheckboxes(basePath, mid, sid);
+      planUpdated = true;
+    }
   }
 
   // 3. Try to revert git commits from activity log
@@ -379,6 +389,37 @@ export async function handleResetSlice(
 
 // ─── Helpers ──────────────────────────────────────────────────────────────────
 
+// Known unit types sorted longest-first so a more specific type (e.g.
+// "execute-task-simple") matches before a prefix of it ("execute-task") when
+// splitting "<seq>-<unitType>-<unitId>.jsonl".
+const UNIT_TYPES_BY_LENGTH_DESC: readonly string[] = Object.keys(UNIT_REGISTRY).sort(
+  (a, b) => b.length - a.length,
+);
+
+/**
+ * Parse an activity-log filename of the form `<seq>-<unitType>-<unitId>.jsonl`
+ * (the format written by activity-log.ts). Both the unit type and the unit ID
+ * may contain hyphens, so we anchor on the known unit-type vocabulary rather
+ * than guessing the ID shape. This keeps non-milestone IDs (e.g. PROJECT,
+ * WORKFLOW-PREFS) parseable. Returns null when the name has no sequence prefix
+ * or does not start with a recognised unit type.
+ */
+export function parseActivityLogFilename(
+  filename: string,
+): { unitType: string; unitId: string } | null {
+  const seqMatch = filename.match(/^\d+-(.+)\.jsonl$/);
+  if (!seqMatch) return null;
+  const rest = seqMatch[1];
+  for (const unitType of UNIT_TYPES_BY_LENGTH_DESC) {
+    const prefix = `${unitType}-`;
+    if (rest.startsWith(prefix)) {
+      const unitId = rest.slice(prefix.length);
+      if (unitId.length > 0) return { unitType, unitId };
+    }
+  }
+  return null;
+}
+
 export function uncheckTaskInPlan(basePath: string, mid: string, sid: string, tid: string): boolean {
   const slicePath = resolveSlicePath(basePath, mid, sid);
   if (!slicePath) return false;

package/src/resources/extensions/gsd/verification-gate.ts

@@ -244,6 +244,14 @@ export function formatFailureContext(result: VerificationResult): string {
   return header + body;
 }
 
+export function formatFailureSignature(result: VerificationResult): string {
+  return result.checks
+    .filter((check) => check.exitCode !== 0)
+    .map((check) => `${check.command.trim()}#${check.exitCode}`)
+    .sort()
+    .join("\n");
+}
+
 // ─── Gate Execution ─────────────────────────────────────────────────────────
 
 /** Characters that indicate shell control syntax when unquoted in a command string. */

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

@@ -414,9 +414,12 @@ function restoreArtifactProjections(basePath: string, manifest: StateManifest):
   if (manifest.artifacts === undefined) return;
 
   for (const artifact of manifest.artifacts) {
+    const content = artifact.full_content ?? "";
+    if (content === "") continue;
+
     atomicWriteSync(
       artifactProjectionPath(basePath, artifact.path),
-      artifact.full_content ?? "",
+      content,
     );
   }
 }