@opengsd/gsd-core 1.5.0-rc.5 → 1.5.0

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "gsd-core",
   "displayName": "GSD Core",
-  "version": "1.5.0-rc.5",
+  "version": "1.5.0",
   "description": "GSD Core is a meta-prompting, context engineering, and spec-driven development system for AI coding agents.",
   "author": {
     "name": "open-gsd",

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2025 Lex Christopherson
+Copyright (c) 2026 Open GSD
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/agents/gsd-executor.md

@@ -103,6 +103,24 @@ PLAN_START_EPOCH=$(date +%s)
 ```
 </step>
 
+<worktree_metadata_capture>
+If running inside a git worktree, capture authoritative worktree identity before
+any task commit changes HEAD. The execute-phase orchestrator consumes this from
+your final `<worktree_metadata>` return block to build the wave cleanup manifest
+without relying on runtime harness metadata (#1297).
+
+```bash
+GSD_WORKTREE_PATH=""
+GSD_WORKTREE_BRANCH=""
+GSD_WORKTREE_EXPECTED_BASE=""
+if [ -f .git ]; then
+  GSD_WORKTREE_PATH=$(git rev-parse --show-toplevel)
+  GSD_WORKTREE_BRANCH=$(git rev-parse --abbrev-ref HEAD)
+  GSD_WORKTREE_EXPECTED_BASE=$(git rev-parse HEAD)
+fi
+```
+</worktree_metadata_capture>
+
 <step name="determine_execution_pattern">
 ```bash
 grep -n "type=\"checkpoint" [plan-path]
@@ -761,6 +779,10 @@ into the user's project history.
 **Tasks:** {completed}/{total}
 **SUMMARY:** {path to SUMMARY.md}
 
+<worktree_metadata>
+{"agent_id":"{phase}-{plan}","worktree_path":"${GSD_WORKTREE_PATH:-}","branch":"${GSD_WORKTREE_BRANCH:-}","expected_base":"${GSD_WORKTREE_EXPECTED_BASE:-}"}
+</worktree_metadata>
+
 **Commits:**
 - {hash}: {message}
 - {hash}: {message}

package/bin/install.js

@@ -1796,6 +1796,10 @@ function skillFrontmatterName(skillDirName) {
   return skillDirName;
 }
 
+function normalizeClaudeSkillEffort(effort) {
+  return effort === 'xhigh' ? 'max' : effort;
+}
+
 /**
  * Qwen Code skills accept an optional numeric `priority` frontmatter field.
  * Per the Qwen skills spec (qwen-code/docs/users/features/skills.md, verified
@@ -1892,7 +1896,7 @@ function convertClaudeCommandToClaudeSkill(content, skillName, runtime = null, c
   // token-budget tier). Fields are Claude-specific; unknown frontmatter
   // fields are silently ignored by other runtimes (backward-compatible).
   if (context) fm += `context: ${context}\n`;
-  if (effort) fm += `effort: ${effort}\n`;
+  if (effort) fm += `effort: ${normalizeClaudeSkillEffort(effort)}\n`;
   if (toolsBlock) fm += toolsBlock;
   fm += '---';
 
@@ -3194,110 +3198,55 @@ function generateCodexAgentToml(agentName, agentContent, modelOverrides = null,
 }
 
 /**
- * Generate the agents/openai.yaml TUI chip metadata content for a Codex skill.
- *
- * This file is written alongside SKILL.md as <skill-dir>/agents/openai.yaml.
- * Codex loads it as a SkillMetadataFile (codex-rs/core-skills/src/loader.rs),
- * making the skill discoverable in the /skills TUI popup with a display name
- * and short description. If the file is absent, Codex silently skips it (fails open).
- *
- * Schema (interface section):
- *   display_name: short human-readable skill name (strip gsd- prefix)
- *   short_description: 1-2 sentence description for TUI chip, ≤180 chars
- *
- * @param {string} skillName - Full skill name e.g. "gsd-plan-phase"
- * @param {string} shortDescription - Description text (already truncated by caller)
- * @returns {string} YAML content for agents/openai.yaml
- */
-function generateCodexSkillMetadataYaml(skillName, shortDescription) {
-  // Display name: strip "gsd-" prefix and convert hyphens to spaces for readability.
-  const displayName = skillName.replace(/^gsd-/, '').replace(/-/g, ' ');
-  // yamlQuote (= JSON.stringify) handles all YAML-unsafe chars: backslashes,
-  // quotes, newlines, control characters, and Unicode escapes.
-  return [
-    'interface:',
-    `  display_name: ${yamlQuote(displayName)}`,
-    `  short_description: ${yamlQuote(shortDescription)}`,
-    '',
-  ].join('\n');
-}
-
-/**
- * Write agents/openai.yaml TUI chip metadata for each gsd-* skill directory.
- *
- * Called after layout-driven skill install for Codex. Iterates every gsd-*
- * skill directory in skillsDir, reads the SKILL.md frontmatter to extract the
- * short-description already emitted by convertClaudeCommandToCodexSkill, then
- * writes <skill-dir>/agents/openai.yaml using generateCodexSkillMetadataYaml.
+ * Remove stale agents/openai.yaml sidecar files from GSD-managed Codex skill dirs.
  *
- * Fails open: individual skill directories that cannot be processed are silently
- * skipped so a single malformed SKILL.md cannot block the whole install.
+ * Prior to #1326, GSD's Codex install path wrote an agents/openai.yaml file
+ * alongside each gsd-* SKILL.md. Recent Codex builds index BOTH SKILL.md and
+ * the sidecar, causing each GSD skill to appear twice in autocomplete. This
+ * function removes those stale sidecars and — if the agents/ subdirectory is
+ * now empty — prunes it too.
  *
- * User-owned skill directories (e.g. gsd-dev-preferences) are explicitly
- * skipped so existing user-authored agents/openai.yaml files are never
- * overwritten. These dirs are listed in the same USER_OWNED_SKILL_DIRS
- * constant used by installOpencodeFamilySkills.
- *
- * The YAML-quoted description value is unescaped before embedding so that
- * YAML escape sequences (e.g. \" in a double-quoted scalar) become the
- * literal characters they represent rather than being double-escaped in the
- * output.
+ * Behaviour:
+ *   - Returns immediately if skillsDir does not exist (fails open).
+ *   - Only touches directories whose names start with "gsd-".
+ *   - Skips user-owned dirs (gsd-dev-preferences) — their agents/ content is
+ *     never modified, mirroring the same USER_OWNED_SKILL_DIRS guard used by
+ *     installOpencodeFamilySkills.
+ *   - For each managed gsd-* dir, if agents/openai.yaml exists, deletes it.
+ *   - If agents/ is now empty, removes the directory; if it still contains
+ *     other files (e.g. user-added content), leaves it in place.
+ *   - Non-gsd-* dirs and their agents/ content are never touched.
+ *   - Individual failures are caught and swallowed so a single bad dir cannot
+ *     block the install (fail-open, matching the original design).
  *
  * @param {string} skillsDir - Path to the skills/ directory (e.g. ~/.codex/skills)
  */
-function writeCodexSkillMetadataFiles(skillsDir) {
+function cleanupCodexSkillMetadataSidecars(skillsDir) {
   if (!fs.existsSync(skillsDir)) return;
   // Mirror the user-owned list from installOpencodeFamilySkills (#2973).
   // We MUST skip these dirs — their contents are user-generated and must
-  // never be overwritten by GSD's install path.
+  // never be modified by GSD's install path.
   const _userOwnedSkillDirs = new Set(['gsd-dev-preferences']);
   for (const entry of fs.readdirSync(skillsDir, { withFileTypes: true })) {
     if (!entry.isDirectory() || !entry.name.startsWith('gsd-')) continue;
     if (_userOwnedSkillDirs.has(entry.name)) continue; // preserve user content
-    const skillDir = path.join(skillsDir, entry.name);
-    const skillMdPath = path.join(skillDir, 'SKILL.md');
+    const agentsSubdir = path.join(skillsDir, entry.name, 'agents');
+    const sidecarPath = path.join(agentsSubdir, 'openai.yaml');
     try {
-      const content = fs.readFileSync(skillMdPath, 'utf8');
-      const { frontmatter } = extractFrontmatterAndBody(content);
-      // Prefer the short-description field emitted by convertClaudeCommandToCodexSkill;
-      // fall back to description, then a synthetic label from the skill name.
-      let shortDesc = '';
-      if (frontmatter) {
-        // SKILL.md uses YAML frontmatter with a nested metadata.short-description key.
-        // extractFrontmatterField handles only top-level keys; parse the metadata block
-        // by looking for "  short-description:" directly.
-        const metaMatch = frontmatter.match(/^[ \t]*metadata\s*:\s*\n((?:[ \t]+.*\n?)*)/m);
-        if (metaMatch) {
-          const metaBlock = metaMatch[1];
-          const sdMatch = metaBlock.match(/^[ \t]+short-description\s*:\s*(.+)$/m);
-          if (sdMatch) {
-            // Unescape YAML double-quoted scalar escapes before embedding.
-            // convertClaudeCommandToCodexSkill always emits a double-quoted
-            // value (via yamlQuote) so only double-quote unescaping is needed.
-            let raw = sdMatch[1].trim();
-            if (raw.startsWith('"') && raw.endsWith('"')) {
-              // Strip outer double-quotes and decode \" → " and \\ → \
-              raw = raw.slice(1, -1).replace(/\\"/g, '"').replace(/\\\\/g, '\\');
-            } else {
-              // Single-quoted or unquoted: strip surrounding quotes/whitespace
-              raw = raw.replace(/^["']|["']$/g, '');
-            }
-            shortDesc = raw;
-          }
-        }
-        if (!shortDesc) {
-          shortDesc = extractFrontmatterField(frontmatter, 'description') || '';
-        }
+      // Symlink guard: if agents/ is a symlink pointing outside the skills tree,
+      // deleting through it could escape the tree. Skip this dir entirely.
+      let agentsStat;
+      try { agentsStat = fs.lstatSync(agentsSubdir); } catch (_e) { continue; }
+      if (agentsStat.isSymbolicLink()) continue;
+      if (fs.existsSync(sidecarPath)) {
+        fs.rmSync(sidecarPath);
+      }
+      // Prune the agents/ dir only if it is now empty (leave it if other files remain).
+      if (fs.existsSync(agentsSubdir) && fs.readdirSync(agentsSubdir).length === 0) {
+        fs.rmdirSync(agentsSubdir);
       }
-      if (!shortDesc) {
-        shortDesc = `Run GSD workflow ${entry.name}.`;
-      }
-      const yamlContent = generateCodexSkillMetadataYaml(entry.name, shortDesc);
-      const agentsSubdir = path.join(skillDir, 'agents');
-      fs.mkdirSync(agentsSubdir, { recursive: true });
-      fs.writeFileSync(path.join(agentsSubdir, 'openai.yaml'), yamlContent);
     } catch (_err) {
-      // Fail open — missing or unreadable SKILL.md must not block the install.
+      // Fail open — a single bad dir must not block the install.
     }
   }
 }
@@ -6843,6 +6792,12 @@ function _applyRuntimeRewrites(content, runtime, pathPrefix, isGlobal = false) {
       content = content.replace(/~\/\.claude\//g, pathPrefix);
       content = content.replace(/\$HOME\/\.claude\//g, pathPrefix);
       content = content.replace(/\.\/\.claude\//g, `./${dirName}/`);
+      // Bare forms (no trailing slash) — use (?![\w-]) instead of \b so that
+      // .claude-plugin / .claudeignore are NOT corrupted (the \b word-boundary
+      // fires between 'e' and '-', which rewrites .claude-plugin → .cursor-plugin).
+      content = content.replace(/~\/\.claude(?![\w-])/g, normalizedPathPrefix);
+      content = content.replace(/\$HOME\/\.claude(?![\w-])/g, normalizedPathPrefix);
+      content = content.replace(/\.\/\.claude(?![\w-])/g, `./${dirName}`);
       content = content.replace(/~\/\.cursor\//g, pathPrefix);
       content = processAttribution(content, getCommitAttribution(runtime));
       break;
@@ -9837,14 +9792,14 @@ function install(isGlobal, runtime = 'claude', options = {}) {
     const scope = isGlobal ? 'global' : 'local';
     installRuntimeArtifacts(runtime, targetDir, scope, _resolvedProfile);
 
-    // #774 — Codex only: write agents/openai.yaml TUI chip metadata alongside each
-    // installed skill so the /skills popup shows name + description for each gsd-* skill.
-    // The SkillMetadataFile is loaded by codex-rs/core-skills/src/loader.rs from
-    // <skill-dir>/agents/openai.yaml; absence is silently tolerated (fails open).
-    // We parse the SKILL.md frontmatter to extract short-description already emitted
-    // by convertClaudeCommandToCodexSkill and use it as the TUI chip description.
+    // #1326 — Codex only: remove stale agents/openai.yaml sidecars from managed
+    // gsd-* skill dirs. Prior installs wrote these files so Codex would show a
+    // display name and description in the /skills TUI popup. Recent Codex builds
+    // index BOTH SKILL.md and the sidecar, causing each GSD skill to appear twice
+    // in autocomplete. Cleaning them up fixes the duplication; SKILL.md alone is
+    // sufficient for Codex discovery. User-owned dirs are never touched.
     if (isCodex) {
-      writeCodexSkillMetadataFiles(path.join(targetDir, 'skills'));
+      cleanupCodexSkillMetadataSidecars(path.join(targetDir, 'skills'));
     }
 
     // Hermes only: write DESCRIPTION.md for the gsd/ category after layout install
@@ -12126,8 +12081,7 @@ module.exports = {
     convertClaudeToGeminiAgent,
     convertClaudeAgentToCodexAgent,
     generateCodexAgentToml,
-    generateCodexSkillMetadataYaml,
-    writeCodexSkillMetadataFiles,
+    cleanupCodexSkillMetadataSidecars,
     generateCodexConfigBlock,
     stripGsdFromCodexConfig,
     migrateCodexHooksMapFormat,

package/commands/gsd/autonomous.md

@@ -2,7 +2,7 @@
 name: gsd:autonomous
 description: Run all remaining phases autonomously — discuss→plan→execute per phase
 argument-hint: "[--from N] [--to N] [--only N] [--interactive] [--converge]"
-effort: xhigh
+effort: max
 allowed-tools:
   - Read
   - Write

package/commands/gsd/execute-phase.md

@@ -2,7 +2,7 @@
 name: gsd:execute-phase
 description: Execute all plans in a phase with wave-based parallelization
 argument-hint: "<phase-number> [--wave N] [--gaps-only] [--interactive] [--tdd]"
-effort: xhigh
+effort: max
 allowed-tools:
   - Read
   - Write

package/commands/gsd/plan-phase.md

@@ -2,7 +2,7 @@
 name: gsd:plan-phase
 description: Create detailed phase plan (PLAN.md) with verification loop
 argument-hint: "[phase] [--auto] [--research] [--skip-research] [--research-phase <N>] [--view] [--gaps] [--skip-verify] [--prd <file>] [--ingest <path-or-glob>] [--ingest-format <auto|nygard|madr|narrative>] [--reviews] [--text] [--tdd] [--mvp]"
-effort: xhigh
+effort: max
 allowed-tools:
   - Read
   - Write

package/gemini-extension.json

@@ -1,6 +1,6 @@
 {
   "name": "gsd-core",
-  "version": "1.5.0-rc.5",
+  "version": "1.5.0",
   "description": "GSD Core — a meta-prompting, context engineering, and spec-driven development system for AI coding agents. Loads gsd's operating context into every Gemini CLI session.",
   "contextFileName": "GEMINI.md"
 }

package/gsd-core/bin/gsd-tools.cjs

@@ -1519,6 +1519,17 @@ async function runCommand(command, args, cwd, raw, defaultValue, originalCommand
       break;
     }
 
+    // ─── teams-status ──────────────────────────────────────────────────────
+    // Read-only detector for claude-code's experimental agent-teams feature.
+    // issue #1355: stop gsd-core hanging silently under claude-code agent-teams.
+    // No capability registration needed — this is a diagnostic query command,
+    // not a feature capability.
+    case 'teams-status': {
+      const teamsStatus = require('./lib/teams-status.cjs');
+      teamsStatus.cmdTeamsStatus(cwd, { active: args.includes('--active') });
+      break;
+    }
+
     // ─── detect-custom-files ───────────────────────────────────────────────
     // CJS-native: no SDK counterpart exists in the command registry.
     // detect-custom-files reads a gsd-file-manifest.json against the
@@ -1566,18 +1577,30 @@ async function runCommand(command, args, cwd, raw, defaultValue, originalCommand
 
       const manifestKeys = new Set(Object.keys(manifest.files || {}));
 
-      // GSD-managed directories to scan for user-added files.
-      // These are the directories the installer wipes on update.
-      const GSD_MANAGED_DIRS = [
+      // GSD-managed directories to scan for user-added files. Whole-owned
+      // roots are wiped recursively; shared runtime roots are pruned by the
+      // same gsd-* top-level prefix used by install.js _removeGsdEntries.
+      const GSD_WHOLE_MANAGED_DIRS = [
         'gsd-core',
-        'agents',
         path.join('commands', 'gsd'),
+      ];
+      const GSD_PREFIX_MANAGED_DIRS = [
+        'agents',
         'hooks',
         'skills',
       ];
 
       function collectCustomFiles(dir, baseDir, manifestKeys, out) {
         if (!fs.existsSync(dir)) return;
+        const stat = fs.statSync(dir);
+        if (stat.isFile()) {
+          const relPath = path.relative(baseDir, dir).replace(/\\/g, '/');
+          if (!manifestKeys.has(relPath)) {
+            out.push(relPath);
+          }
+          return;
+        }
+        if (!stat.isDirectory()) return;
         for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
           const fullPath = path.join(dir, entry.name);
           if (entry.isDirectory()) {
@@ -1593,11 +1616,19 @@ async function runCommand(command, args, cwd, raw, defaultValue, originalCommand
       }
 
       const customFiles = [];
-      for (const managedDir of GSD_MANAGED_DIRS) {
+      for (const managedDir of GSD_WHOLE_MANAGED_DIRS) {
         const absDir = path.join(resolvedConfigDir, managedDir);
         if (!fs.existsSync(absDir)) continue;
         collectCustomFiles(absDir, resolvedConfigDir, manifestKeys, customFiles);
       }
+      for (const managedDir of GSD_PREFIX_MANAGED_DIRS) {
+        const absDir = path.join(resolvedConfigDir, managedDir);
+        if (!fs.existsSync(absDir)) continue;
+        for (const entry of fs.readdirSync(absDir, { withFileTypes: true })) {
+          if (!entry.name.startsWith('gsd-')) continue;
+          collectCustomFiles(path.join(absDir, entry.name), resolvedConfigDir, manifestKeys, customFiles);
+        }
+      }
 
       const out = {
         custom_files: customFiles,

package/gsd-core/bin/lib/decisions.cjs

@@ -61,7 +61,13 @@ function parseDecisions(content) {
     // in addition to numeric-only IDs (D-42). The first character after `D-` must
     // be alphanumeric, so malformed shapes like `D--foo` or `D-_bar` are rejected.
     // CJS callers consume {id, text} and ignore the optional extras.
-    const bulletRe = /^\s*-\s+\*\*D-([A-Za-z0-9][A-Za-z0-9_-]*)(?:\s*\[([^\]]+)\])?\s*:\*\*\s*(.*)$/;
+    // #1343: `[^:*]*` replaces the old `\s*` before `:**` so that a freeform run
+    // such as `(parenthetical)`, an em-dash, or other prose between the optional
+    // bracket-tag group and the closing `:**` is tolerated rather than silently
+    // dropping the whole decision. `[^:*]*` subsumes plain whitespace and stops
+    // correctly at `:**`. Capture groups 1 (id), 2 (bracket tags), 3 (text) are
+    // unchanged.
+    const bulletRe = /^\s*-\s+\*\*D-([A-Za-z0-9][A-Za-z0-9_-]*)(?:\s*\[([^\]]+)\])?[^:*]*:\*\*\s*(.*)$/;
     let current = null;
     const flush = () => {
         if (current) {
@@ -102,6 +108,18 @@ function parseDecisions(content) {
             current = { id, text: bulletMatch[3], category, tags, trackable };
             continue;
         }
+        // Parse-miss guard (#1343): a line that looks like a `D-NN` decision bullet
+        // but failed `bulletRe` (e.g. a `:` or `*` inside the pre-colon run) must NOT
+        // be silently dropped — a narrowed trackable set lets a blocking coverage gate
+        // report a false pass. Surface it loudly instead.
+        if (/^\s*-\s+\*\*D-/.test(line)) {
+            // A malformed D-bullet still starts a (failed) new decision, so it ends the
+            // previous one — flush before warning so a following continuation line cannot
+            // be mis-appended to the prior valid decision.
+            flush();
+            console.warn(`parseDecisions: ignored unparseable decision bullet: ${trimmed}`);
+            continue;
+        }
         // Continuation line for current decision (indented with space OR tab,
         // non-bullet, non-empty) — tab indentation must work too (review F12).
         if (current && trimmed !== '' && !trimmed.startsWith('-') && /^[ \t]/.test(line)) {

package/gsd-core/bin/lib/phase-id.cjs

@@ -173,7 +173,7 @@ function extractPhaseToken(dirName) {
     const tokenSegments = [];
     for (let i = 0; i < segments.length; i++) {
         const seg = segments[i];
-        if (/^\d/.test(seg)) {
+        if (/^\d/.test(seg) || (i === 0 && /^[A-Za-z]{1,3}\d/.test(seg))) {
             tokenSegments.push(seg);
         }
         else {

package/gsd-core/bin/lib/phase.cjs

@@ -1040,6 +1040,22 @@ function writePlanningFileSet(writes) {
         throw err;
     }
 }
+function phaseDisplayNameFromRoadmap(roadmapContent, phaseNum) {
+    if (!roadmapContent || !phaseNum)
+        return null;
+    const phaseEscaped = phaseMarkdownRegexSource(phaseNum);
+    const heading = roadmapContent.match(new RegExp(`^#{2,4}\\s*Phase\\s+${phaseEscaped}\\s*:\\s*([^\\n]+)`, 'im'));
+    if (!heading)
+        return null;
+    const name = heading[1].replace(/\(INSERTED\)/i, '').trim();
+    return name || null;
+}
+function phaseDisplayNameFromSlug(slug) {
+    if (!slug)
+        return null;
+    const name = slug.replace(/-/g, ' ').trim();
+    return name || null;
+}
 function cmdPhaseComplete(cwd, phaseNum, raw) {
     if (!phaseNum) {
         error('phase number required for phase complete');
@@ -1287,6 +1303,8 @@ function cmdPhaseComplete(cwd, phaseNum, raw) {
                 const originalStateContent = (0, shell_command_projection_cjs_1.platformReadSync)(statePath) || '';
                 let stateContent = originalStateContent;
                 const phaseValue = nextPhaseNum || phaseNum;
+                const nextPhaseDisplayName = phaseDisplayNameFromRoadmap(roadmapContent, nextPhaseNum) ??
+                    phaseDisplayNameFromSlug(nextPhaseName);
                 const existingPhaseField = stateExtractField(stateContent, 'Current Phase') ||
                     stateExtractField(stateContent, 'Phase');
                 let newPhaseValue = String(phaseValue);
@@ -1295,22 +1313,39 @@ function cmdPhaseComplete(cwd, phaseNum, raw) {
                     const nameMatch = existingPhaseField.match(/\(([^)]+)\)/);
                     if (totalMatch) {
                         const total = totalMatch[1];
-                        const nameStr = nextPhaseName
-                            ? ` (${nextPhaseName.replace(/-/g, ' ')})`
+                        const nameStr = nextPhaseDisplayName
+                            ? ` (${nextPhaseDisplayName})`
                             : nameMatch
                                 ? ` (${nameMatch[1]})`
                                 : '';
                         newPhaseValue = `${phaseValue} of ${total}${nameStr}`;
                     }
+                    else if (nextPhaseDisplayName) {
+                        newPhaseValue = `${phaseValue} — ${nextPhaseDisplayName}`;
+                    }
                 }
                 stateContent = stateReplaceFieldWithFallback(stateContent, 'Current Phase', 'Phase', newPhaseValue);
-                if (nextPhaseName) {
-                    stateContent = stateReplaceFieldWithFallback(stateContent, 'Current Phase Name', null, nextPhaseName.replace(/-/g, ' '));
+                if (nextPhaseDisplayName) {
+                    stateContent =
+                        stateReplaceField(stateContent, 'Current Phase Name', nextPhaseDisplayName) ||
+                            stateContent;
                 }
                 stateContent = stateReplaceFieldWithFallback(stateContent, 'Status', null, isLastPhase ? 'Milestone complete' : 'Ready to plan');
                 stateContent = stateReplaceFieldWithFallback(stateContent, 'Current Plan', 'Plan', 'Not started');
-                stateContent = stateReplaceFieldWithFallback(stateContent, 'Last Activity', 'Last activity', today);
-                stateContent = stateReplaceFieldWithFallback(stateContent, 'Last Activity Description', null, `Phase ${phaseNum} complete${nextPhaseNum ? `, transitioned to Phase ${nextPhaseNum}` : ''}`);
+                const lastActivityDescription = `Phase ${phaseNum} complete${nextPhaseNum ? `, transitioned to Phase ${nextPhaseNum}` : ''}`;
+                if (/^Last activity:/m.test(stateContent)) {
+                    stateContent =
+                        stateReplaceField(stateContent, 'Last activity', `${today} — ${lastActivityDescription}`) ||
+                            stateContent;
+                }
+                else {
+                    stateContent =
+                        stateReplaceField(stateContent, 'Last Activity', today) ||
+                            stateContent;
+                }
+                stateContent =
+                    stateReplaceField(stateContent, 'Last Activity Description', lastActivityDescription) ||
+                        stateContent;
                 const completedRaw = stateExtractField(stateContent, 'Completed Phases');
                 if (completedRaw !== null) {
                     let newCompleted = parseInt(completedRaw, 10);

package/gsd-core/bin/lib/probe-core.cjs

@@ -281,6 +281,13 @@ function projectProhibitions(items) {
             if (kind === 'lint-rule' && typeof p.check_rule === 'string' && p.check_rule.trim() !== '') {
                 entry.check_rule = String(p.check_rule);
             }
+            // `check_violation_fixture` (#1346) rides BOTH kinds — it's what the #1279 prover machine-proves
+            // fail-first against. Emit ONLY a non-empty fixture (a blank one projects absent so green still
+            // hard-gates downstream — never a partial green); meaningless without the descriptor, so it lives
+            // inside this well-formed-descriptor branch.
+            if (typeof p.check_violation_fixture === 'string' && p.check_violation_fixture.trim() !== '') {
+                entry.check_violation_fixture = String(p.check_violation_fixture);
+            }
         }
         out.push(entry);
     }