@opengsd/gsd-core 1.7.0 → 1.9.0

package/gsd-core/bin/lib/runtime-hooks-surface.cjs

@@ -149,6 +149,81 @@ function atomicWriteFileSync(target, data, options) {
     }
 }
 // ---------------------------------------------------------------------------
+// CommonJS package.json marker for staged .js hook scripts (#2717)
+//
+// Node resolves the nearest package.json walking up from a .js file. When a
+// runtime's config root (e.g. ~/.cursor, ~/.codeium/windsurf, ~/.codex) — or any
+// parent — declares {"type":"module"}, Node loads GSD's staged CommonJS hook
+// scripts as ESM and every require() fails with "require is not defined",
+// silently disabling that runtime's lifecycle hooks.
+//
+// installSharedHooksBundle writes this marker for the 12 runtimes that go
+// through the shared hooks bundle, but cursor/windsurf (skipSharedHooksInstall)
+// and codex (the !isCodex gate) stage their .js hooks via the dedicated paths
+// below and never reached it. These helpers decouple the marker write from the
+// shared bundle so any code path that stages .js hooks can ensure the marker
+// lands in the SAME directory as the scripts (#2717).
+//
+// The marker content is byte-identical to installSharedHooksBundle's
+// (bin/install.js installSharedHooksBundle): {"type":"commonjs"}\n.
+// ---------------------------------------------------------------------------
+/** The exact marker content GSD writes, matching installSharedHooksBundle. */
+const COMMONJS_MARKER_CONTENT = '{"type":"commonjs"}\n';
+/**
+ * Ensure a `package.json` forcing CommonJS mode exists in `dir` (the directory
+ * holding GSD-staged `.js` hook scripts). Idempotent: a no-op if the marker is
+ * already present with GSD's content. Overwrites only when the file is absent
+ * or already carries GSD's exact marker — it never clobbers a distinct
+ * user-authored package.json (it leaves such a file in place; the user owns it).
+ *
+ * @param dir - absolute path to the directory holding the staged .js hooks
+ * @returns `true` if the marker is present after the call (written or already there)
+ */
+function ensureCommonJsMarker(dir) {
+    const markerPath = node_path_1.default.join(dir, 'package.json');
+    try {
+        if (node_fs_1.default.existsSync(markerPath)) {
+            const existing = node_fs_1.default.readFileSync(markerPath, 'utf8');
+            // Already GSD's marker (tolerant of trailing-whitespace variants) — done.
+            if (existing.trim() === '{"type":"commonjs"}')
+                return true;
+            // A distinct package.json the user owns — do NOT clobber. The hook will
+            // load as whatever type the user declared; that is the user's choice.
+            return false;
+        }
+        node_fs_1.default.writeFileSync(markerPath, COMMONJS_MARKER_CONTENT);
+        return true;
+    }
+    catch {
+        // Best-effort: a marker write failure must not fail the whole install.
+        return false;
+    }
+}
+/**
+ * Remove the CommonJS marker from `dir` on uninstall — but ONLY if it carries
+ * GSD's exact marker content. A user-authored package.json is never deleted.
+ * Mirrors the kimi uninstall guard in bin/install.js.
+ *
+ * @param dir - absolute path to the directory that held the staged .js hooks
+ * @returns `true` if a GSD-owned marker was removed
+ */
+function removeCommonJsMarkerIfGsdOwned(dir) {
+    const markerPath = node_path_1.default.join(dir, 'package.json');
+    try {
+        if (!node_fs_1.default.existsSync(markerPath))
+            return false;
+        const content = node_fs_1.default.readFileSync(markerPath, 'utf8').trim();
+        if (content === '{"type":"commonjs"}') {
+            node_fs_1.default.unlinkSync(markerPath);
+            return true;
+        }
+        return false;
+    }
+    catch {
+        return false;
+    }
+}
+// ---------------------------------------------------------------------------
 // parseTomlValue + findMultilineBasicStringClose
 // (needed by rewriteLegacyCodexHookBlock — pure TOML helpers, no state)
 // ---------------------------------------------------------------------------
@@ -309,6 +384,22 @@ function normalizeNodePath(execPath, opts) {
         if (existsSync(shim))
             return shim;
     }
+    // volta pins a concrete node image at <VOLTA_HOME>/tools/image/node/<ver>/bin/node
+    // (Windows: <VOLTA_HOME>/tools/image/node/<ver>/node.exe — volta's own layout
+    // puts node.exe at the image root, no bin/). `volta uninstall node@<ver>` prunes
+    // that image, so a baked hook command 404s — the same ephemeral-path failure
+    // #977 fixed for fnm and #1619 for mise. The stable alias is the shim
+    // <VOLTA_HOME>/bin/node, a symlink to volta-shim that always resolves to the
+    // active pin. Derive <VOLTA_HOME> from execPath rather than the env so a custom
+    // VOLTA_HOME and the Windows %LOCALAPPDATA%\Volta default both work (#2185's
+    // reasoning), and only rewrite when the shim exists — otherwise fall back to
+    // the raw execPath unchanged.
+    const voltaMatch = normalizedForMatch.match(/^(.*)\/tools\/image\/node\/[^/]+\/(?:bin\/)?node(\.exe)?$/);
+    if (voltaMatch) {
+        const shim = `${voltaMatch[1]}/bin/node${voltaMatch[2] || ''}`;
+        if (existsSync(shim))
+            return shim;
+    }
     return execPath;
 }
 function resolveNodeRunner(opts) {
@@ -940,6 +1031,48 @@ function writeCursorHooksJson(targetDir, src, opts) {
             installedScripts.add(script);
         }
     }
+    // Stage the hooks/lib/ helpers the staged scripts require (#2587). Cursor sets
+    // hostBehaviors.skipSharedHooksInstall, so it never reaches the installer's
+    // bulk hooks/lib copy — without this, a script requiring './lib/…' would throw
+    // MODULE_NOT_FOUND at load, BEFORE its own try/catch, and wedge every Cursor
+    // session on the one runtime these hooks exist for. Driven off what the staged
+    // scripts actually require so a future helper cannot be silently omitted.
+    const requiredLibFiles = new Set();
+    for (const script of installedScripts) {
+        const staged = node_fs_1.default.readFileSync(node_path_1.default.join(hooksDir, script), 'utf8');
+        // Tolerant of interior whitespace and either quote style: a hook author
+        // writing `require( "./lib/x.js" )` must still get its helper staged, since
+        // a miss here surfaces as MODULE_NOT_FOUND at hook load, not at install.
+        const re = /require\(\s*['"]\.\/lib\/([A-Za-z0-9._-]+)['"]\s*\)/g;
+        let m;
+        while ((m = re.exec(staged)) !== null)
+            requiredLibFiles.add(m[1]);
+    }
+    if (requiredLibFiles.size > 0) {
+        const srcLibDir = node_path_1.default.join(srcHooksDir, 'lib');
+        const destLibDir = node_path_1.default.join(hooksDir, 'lib');
+        node_fs_1.default.mkdirSync(destLibDir, { recursive: true });
+        for (const libFile of requiredLibFiles) {
+            const libSrc = node_path_1.default.join(srcLibDir, libFile);
+            if (!node_fs_1.default.existsSync(libSrc)) {
+                // FAIL LOUD. Skipping here would ship hook scripts whose top-level
+                // require() throws before their own try/catch, wedging every session —
+                // and the install would still exit 0, so nobody would know until a user
+                // hit it. A missing helper source is a packaging bug; surface it.
+                throw new Error(`hooks/lib/${libFile} is required by a staged Cursor hook but is missing from ${srcLibDir}. `
+                    + 'Installing would ship a hook that throws MODULE_NOT_FOUND at load.');
+            }
+            let libContent = node_fs_1.default.readFileSync(libSrc, 'utf8');
+            libContent = libContent.replace(/gsd:/gi, 'gsd-');
+            node_fs_1.default.writeFileSync(node_path_1.default.join(destLibDir, libFile), libContent);
+        }
+    }
+    // #2717: write the CommonJS marker into hooks/ alongside the staged .js
+    // scripts. Cursor sets skipSharedHooksInstall, so it never reaches
+    // installSharedHooksBundle (the only other writer of this marker); without
+    // it, a ~/.cursor/package.json declaring {"type":"module"} makes Node load
+    // these require()-using scripts as ESM and every Cursor hook fails silently.
+    ensureCommonJsMarker(hooksDir);
     const hookOpts = { runtime: 'cursor', platform: opts.platform || process.platform };
     const commands = {};
     for (const ev of events) {
@@ -971,6 +1104,14 @@ function removeCursorHooksJson(targetDir) {
             const hasAnyEvents = Object.keys(hookTable).some((k) => Array.isArray(hookTable[k]) && hookTable[k].length > 0);
             if (!hasAnyEvents) {
                 node_fs_1.default.unlinkSync(hooksJsonPath);
+                // #2717: also remove the CommonJS marker GSD wrote into hooks/ — but
+                // only if it still carries GSD's exact content (a user-authored
+                // package.json is never deleted). Best-effort: a failure here must not
+                // mask the hooks.json removal above.
+                try {
+                    removeCommonJsMarkerIfGsdOwned(node_path_1.default.join(targetDir, 'hooks'));
+                }
+                catch { /* leave it */ }
                 return { changed: true };
             }
         }
@@ -1120,6 +1261,12 @@ function writeWindsurfHooksJson(targetDir, src, opts) {
             installedScripts.add(script);
         }
     }
+    // #2717: write the CommonJS marker into hooks/ alongside the staged .js
+    // scripts. Windsurf sets skipSharedHooksInstall, so it never reaches
+    // installSharedHooksBundle (the only other writer of this marker); without
+    // it, a config-root package.json declaring {"type":"module"} makes Node load
+    // these require()-using scripts as ESM and the Windsurf hooks fail silently.
+    ensureCommonJsMarker(hooksDir);
     const hookOpts = { runtime: 'windsurf', platform: opts.platform || process.platform };
     const commands = {};
     for (const ev of WINDSURF_HOOK_EVENTS) {
@@ -1158,6 +1305,13 @@ function removeWindsurfHooksJson(targetDir) {
             const hasAnyEvents = Object.keys(hookTable).some((k) => Array.isArray(hookTable[k]) && hookTable[k].length > 0);
             if (!hasAnyEvents) {
                 node_fs_1.default.unlinkSync(hooksJsonPath);
+                // #2717: also remove the CommonJS marker GSD wrote into hooks/ — but
+                // only if it still carries GSD's exact content (a user-authored
+                // package.json is never deleted). Best-effort.
+                try {
+                    removeCommonJsMarkerIfGsdOwned(node_path_1.default.join(targetDir, 'hooks'));
+                }
+                catch { /* leave it */ }
                 return { changed: true };
             }
         }
@@ -1947,6 +2101,8 @@ module.exports = {
     GSD_WINDSURF_PRE_WRITE_HOOK_SCRIPT,
     GSD_WINDSURF_PRE_COMMAND_HOOK_SCRIPT,
     GSD_WINDSURF_HOOK_SCRIPTS,
+    ensureCommonJsMarker,
+    removeCommonJsMarkerIfGsdOwned,
     GSD_WINDSURF_HOOK_MARKER,
     // Copilot
     buildCopilotHookConfig,

package/gsd-core/bin/lib/runtime-name-policy.cjs

@@ -40,6 +40,7 @@ const FALLBACK_ALIASES = {
     qwen: ['qwen', 'qwen-code', 'qwen-cli'],
     hermes: ['hermes', 'hermes-agent', 'hermes-cli'],
     kimi: ['kimi'],
+    'kimi-code': ['kimi-code', 'kimicode', 'kimi_code'],
     codebuddy: ['codebuddy', 'codebuddy-cli'],
     cline: ['cline', 'cline-cli'],
 };
@@ -248,6 +249,7 @@ const RUNTIME_LABELS = {
     qwen: 'Qwen Code',
     hermes: 'Hermes Agent',
     kimi: 'Kimi CLI',
+    'kimi-code': 'Kimi Code',
     codebuddy: 'CodeBuddy',
     cline: 'Cline',
     zcode: 'ZCode',
@@ -303,6 +305,7 @@ const GLOBAL_CONFIG_HOME_FRAGMENTS = {
     codebuddy: "'.codebuddy'",
     cline: "'.cline'",
     kimi: "'.config', 'agents'",
+    'kimi-code': "'.kimi-code'",
     zcode: "'.zcode'",
     // pi's global config home is ~/.pi/agent (configHome: dot-home-nested,
     // parent '.pi', name 'agent' — capabilities/pi/capability.json), matching
@@ -337,8 +340,18 @@ function getGlobalConfigHomeFragment(runtime) {
 // folds the shared-hooks-install skip).
 const RUNTIME_FLAG_IDS = Object.freeze([
     'opencode', 'kilo', 'codex', 'copilot', 'antigravity', 'cursor',
-    'windsurf', 'augment', 'trae', 'qwen', 'hermes', 'codebuddy', 'cline', 'kimi', 'zcode', 'pi',
+    'windsurf', 'augment', 'trae', 'qwen', 'hermes', 'codebuddy', 'cline', 'kimi', 'kimi-code', 'zcode', 'pi',
 ]);
+/**
+ * Convert a runtime id (kebab-case, e.g. 'kimi-code') to its `is<Foo>` flag
+ * name in PascalCase (e.g. 'isKimiCode'). The first letter is capitalised and
+ * every `-[a-z]` boundary is folded to its uppercase twin. Single-word ids
+ * (the prior 16: opencode, kilo, codex, …) are unaffected — only hyphenated
+ * ids like 'kimi-code' (#2454) hit the folding branch.
+ */
+function runtimeIdToFlagName(id) {
+    return 'is' + id.charAt(0).toUpperCase() + id.slice(1).replace(/-([a-z])/g, (_m, c) => c.toUpperCase());
+}
 /**
  * Return a frozen map of `is<Runtime>` boolean predicates for the given runtime
  * id (e.g. `flags.isOpencode`). Collapses the four duplicated `const isX =
@@ -349,7 +362,7 @@ const RUNTIME_FLAG_IDS = Object.freeze([
 function runtimeFlags(runtime) {
     const flags = {};
     for (const id of RUNTIME_FLAG_IDS) {
-        flags['is' + id.charAt(0).toUpperCase() + id.slice(1)] = runtime === id;
+        flags[runtimeIdToFlagName(id)] = runtime === id;
     }
     return Object.freeze(flags);
 }

package/gsd-core/bin/lib/smart-entry.cjs

@@ -52,6 +52,9 @@ const { planningPaths } = planningWorkspace;
 // eslint-disable-next-line @typescript-eslint/no-require-imports
 const frontmatter = require("./frontmatter.cjs");
 const { extractFrontmatter } = frontmatter;
+// eslint-disable-next-line @typescript-eslint/no-require-imports -- phase-lifecycle.cjs is an export= CommonJS module
+const phaseLifecycle = require("./phase-lifecycle.cjs");
+const { deriveProgressFromRoadmap } = phaseLifecycle;
 // eslint-disable-next-line @typescript-eslint/no-require-imports
 const stateDocument = require("./state-document.cjs");
 const { stateExtractField } = stateDocument;
@@ -221,7 +224,7 @@ function readStateFile(statePath) {
     catch {
         return null;
     }
-    const fm = extractFrontmatter(content);
+    const fm = extractFrontmatter(content, statePath);
     const body = content.replace(/^---[\s\S]*?---\s*/, '');
     return { fm, body };
 }
@@ -245,6 +248,8 @@ function detectSignals(cwd, now = Date.now) {
         has_git: git.has_git,
         verify_failed: false,
         stale_activity: false,
+        roadmap_total_phases: null,
+        roadmap_completed_phases: null,
     };
     if (!hasPlanning)
         return empty;
@@ -291,6 +296,24 @@ function detectSignals(cwd, now = Date.now) {
     // STATUS: marker on the current phase's summary/verify artifact.
     const verifyFailed = /\bverify-fail(ed)?|verification-fail|uat-fail\b/i.test(statusRaw || '') ||
         detectVerifyFailed(cwd, currentPhaseRaw);
+    // #2427: derive global phase counts from ROADMAP.md's Progress table. These
+    // are preferred over STATE.md's cached milestone-scoped `total_phases` (which
+    // goes stale when phases are appended after a milestone switch) for the
+    // completion check. Null when ROADMAP.md is absent or has no parseable
+    // Progress table — isComplete falls back to the legacy comparison in that case.
+    let roadmapTotalPhases = null;
+    let roadmapCompletedPhases = null;
+    if (hasRoadmap) {
+        try {
+            const roadmapContent = node_fs_1.default.readFileSync(paths.roadmap, 'utf8');
+            const derived = deriveProgressFromRoadmap(roadmapContent);
+            roadmapTotalPhases = derived.totalPhases;
+            roadmapCompletedPhases = derived.completedPhases;
+        }
+        catch {
+            /* ROADMAP.md unreadable — leave null; isComplete falls back to legacy. */
+        }
+    }
     return {
         current_phase: parseIntOrNull(currentPhaseRaw),
         total_phases: parseIntOrNull(totalPhasesRaw),
@@ -305,14 +328,56 @@ function detectSignals(cwd, now = Date.now) {
         has_git: git.has_git,
         verify_failed: verifyFailed,
         stale_activity: staleActivity,
+        roadmap_total_phases: roadmapTotalPhases,
+        roadmap_completed_phases: roadmapCompletedPhases,
     };
 }
 // ─── Situation classification ─────────────────────────────────────────────────
-/** True when the workflow has fully completed all phases. */
+/**
+ * True when the workflow has fully completed all phases.
+ *
+ * #2427: completion is grounded in ROADMAP.md's Progress table (global,
+ * authoritative, never stale) when available, with a legacy fallback to
+ * STATE.md's cached `total_phases` when the roadmap has no parseable Progress
+ * table (e.g. a fresh project or a non-standard roadmap layout). The status
+ * regex was tightened to require milestone-level completion language
+ * (`milestone complete` / `all phases complete` / `complete(d)`) and no longer
+ * matches per-phase messages like "Phase X shipped — PR #N" that falsely
+ * satisfied the pre-fix alternation (`\bcomplete(d)?|done|shipped\b`).
+ */
 function isComplete(s) {
-    if (s.total_phases === null || s.current_phase === null)
-        return false;
-    return s.current_phase >= s.total_phases && /\bcomplete(d)?|done|shipped\b/i.test(s.status);
+    // Prefer ROADMAP-derived counts (global, authoritative) over STATE.md's
+    // cached milestone-scoped total_phases (stale-prone). Fall back to legacy
+    // when the roadmap has no Progress table.
+    if (s.roadmap_total_phases !== null && s.roadmap_completed_phases !== null) {
+        if (s.roadmap_total_phases === 0)
+            return false;
+        if (s.roadmap_completed_phases < s.roadmap_total_phases)
+            return false;
+    }
+    else {
+        // Legacy path: STATE.md comparison. Still subject to the two-scale bug,
+        // but only fires when ROADMAP.md is absent or has no Progress table.
+        if (s.total_phases === null || s.current_phase === null)
+            return false;
+        if (s.current_phase < s.total_phases)
+            return false;
+    }
+    // Status regex: require milestone-level completion language. The pre-fix
+    // regex matched any "shipped" / "done" substring (per-phase language).
+    // Tightened to match:
+    //   - "milestone complete" (ADR-2207 terminal status — usually written as
+    //     "<version> milestone complete", e.g. "v1.0 milestone complete"; the
+    //     substring match handles both forms)
+    //   - "all phases complete" (ADR-2207 intermediate terminal)
+    //   - "complete" / "completed" (legacy short form — STATE.md milestone
+    //     status is a single value, not a per-phase log)
+    // Intentionally does NOT match "done" alone even though normalizeStateStatus
+    // (state-document.cts) treats "done" as "completed" — in the milestone
+    // status field, "done" is per-phase noise (e.g. "Phase X done"), not a
+    // milestone-completion signal. Mirrors workstream-inventory-builder.cts's
+    // terminal pattern \bmilestone\s+complete\b.
+    return /\b(milestone\s+complete|all\s+phases\s+complete|complete(d)?)\b/i.test(s.status);
 }
 /** Idle-stranded: clean tree, committed work not shipped, optionally stale. */
 function isIdleStranded(s) {

package/gsd-core/bin/lib/state-document.cjs

@@ -18,6 +18,7 @@ exports.shouldPreserveExistingProgress = shouldPreserveExistingProgress;
 exports.normalizeProgressNumbers = normalizeProgressNumbers;
 exports.isStateTemplateDefault = isStateTemplateDefault;
 exports.stateReplaceFieldIfTemplate = stateReplaceFieldIfTemplate;
+const markdown_table_cjs_1 = require("./markdown-table.cjs");
 // Internal helpers
 function escapeRegex(str) {
     return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
@@ -40,22 +41,167 @@ function isTableSeparatorRow(firstCell) {
     // A separator cell contains only dashes, colons (alignment hints), and whitespace.
     return /^[\s\-:]+$/.test(firstCell.trim());
 }
+function countLeading(str) {
+    const match = /^[ \t]*/.exec(str);
+    return match ? match[0].length : 0;
+}
+/**
+ * Canonicalize one UTF-16 code unit per the ECMAScript non-unicode
+ * `Canonicalize` abstract operation, which governs how a case-insensitive
+ * (`/i`, no `u` flag) RegExp compares characters: take `ch.toUpperCase()`.
+ * The uppercasing is REJECTED (the original character is kept as-is) in
+ * either of two cases: (1) `ch.toUpperCase()` does not produce exactly one
+ * character (e.g. "ß" -> "SS" — a multi-character case-fold can never be a
+ * per-character regex match, so Canonicalize leaves it alone), or (2) it
+ * produces exactly one character but the original character's code point is
+ * >= 128 while the uppercased character's code point is < 128 (this is what
+ * stops a non-ASCII character from folding onto an ASCII one under `/i` —
+ * e.g. KELVIN SIGN U+212A uppercases to ASCII "K" (U+004B), so this rule
+ * rejects the fold and keeps U+212A, meaning `/k/i`/`/K/i` do NOT match
+ * U+212A). Otherwise, the uppercased character is used. Plain
+ * `.toLowerCase()`/`.toUpperCase()` folds both of these cases, which is
+ * exactly why they diverge from real regex `/i` semantics.
+ */
+function canonicalizeCharForCaselessCompare(ch) {
+    const upper = ch.toUpperCase();
+    if (upper.length !== 1) {
+        return ch;
+    }
+    if (ch.charCodeAt(0) >= 128 && upper.charCodeAt(0) < 128) {
+        return ch;
+    }
+    return upper;
+}
+/**
+ * Canonicalize a whole string, one UTF-16 code unit at a time, per the
+ * ECMAScript non-unicode `Canonicalize` rule (see
+ * canonicalizeCharForCaselessCompare) so that two strings compare equal
+ * under this function iff a non-`u`-flag `/i` RegExp would treat them as
+ * the same literal text. This is the correct replacement for
+ * `.toLowerCase()` when replicating a non-`u` `/i` regex: `.toLowerCase()`
+ * folds some non-ASCII characters (e.g. KELVIN SIGN U+212A) onto their
+ * ASCII counterparts, which real `/i` regex semantics do not. Iteration is
+ * by UTF-16 code unit (not code point) to match how a non-`u` regex engine
+ * itself operates on surrogate halves individually.
+ */
+function canonicalizeForCaselessCompare(str) {
+    let result = '';
+    for (let i = 0; i < str.length; i++) {
+        result += canonicalizeCharForCaselessCompare(str[i]);
+    }
+    return result;
+}
 /**
- * Build a regex that matches a pipe-table row `| FieldName | value |` for the
- * given (already-escaped) field name.  The match is case-insensitive and
- * tolerates variable amounts of whitespace around the cell contents.
+ * Return true when the caller's raw (untrimmed) `fieldName` may be considered
+ * to match a row's raw (untrimmed) field cell text. Faithfully replicates the
+ * backtracking of the regex this function replaced: `^(\|[ \t]*)(FieldName)
+ * ([ \t]*\|...)`. Group 1 (`\|[ \t]*`, greedy but backtrackable) can hand any
+ * PREFIX of the cell's leading `[ \t]` run over to group 2 (the literal,
+ * case-insensitive `fieldName` text) — so `fieldName` is tried at every offset
+ * `j` from 0 up to the length of that leading run. For a given `j` to be a
+ * genuine match, two things must hold: `rawCell.slice(j, j + fieldName.length)`
+ * must equal `fieldName` case-insensitively (group 2), AND everything left
+ * over after it — `rawCell.slice(j + fieldName.length)` — must be entirely
+ * `[ \t]` characters, because group 3 (`[ \t]*\|`) must consume that leftover
+ * as whitespace before it can reach the delimiter pipe.
  *
- * Capture group 1: leading pipe + whitespace before the field cell
- * Capture group 2: the field name cell text (trimmed)
- * Capture group 3: whitespace between field cell and separator pipe
- * Capture group 4: the value cell text (trimmed)
- * Capture group 5: trailing whitespace + closing pipe(s)
+ * A simple count-of-leading/trailing-whitespace comparison is NOT equivalent:
+ * it ignores that group 2 is a literal-character match, not a whitespace-
+ * class match, so it can produce false positives whenever `fieldName`'s own
+ * padding is a different run of `[ \t]` characters than the cell's (e.g.
+ * `fieldName` padded with spaces against a cell padded with tabs) — caught by
+ * differential fuzzing against the regex this replaces.
  *
- * We use a single-line match (`m` flag so ^ anchors work on each line) to
- * avoid cross-row replacement.
+ * The case-insensitive comparison itself is done via
+ * canonicalizeForCaselessCompare, NOT `.toLowerCase()`: the replaced regex
+ * used `/i` WITHOUT the `u` flag, whose case-folding is the ECMAScript
+ * non-unicode `Canonicalize` operation. `.toLowerCase()` folds some non-ASCII
+ * characters onto ASCII ones (e.g. KELVIN SIGN U+212A -> "k") that `/i`
+ * (no `u`) does NOT fold, so `.toLowerCase()` alone would NOT faithfully
+ * replicate the old regex's semantics; canonicalizeForCaselessCompare does.
  */
-function tableRowPattern(escapedFieldName) {
-    return new RegExp(`^(\\|[ \\t]*)(${escapedFieldName})([ \\t]*\\|[ \\t]*)([^|\\n]*?)([ \\t]*\\|[ \\t]*)$`, 'im');
+function fieldNameMatchesRawCell(fieldName, rawCell) {
+    const n = fieldName.length;
+    const cellLength = rawCell.length;
+    if (n > cellLength)
+        return false;
+    const leadingRun = countLeading(rawCell);
+    const maxOffset = Math.min(leadingRun, cellLength - n);
+    const canonicalFieldName = canonicalizeForCaselessCompare(fieldName);
+    for (let j = 0; j <= maxOffset; j++) {
+        if (canonicalizeForCaselessCompare(rawCell.slice(j, j + n)) !== canonicalFieldName)
+            continue;
+        if (/^[ \t]*$/.test(rawCell.slice(j + n)))
+            return true;
+    }
+    return false;
+}
+/**
+ * Locate the value cell of a pipe-table row `| FieldName | value |` for the
+ * given field name, by scanning `content` line by line (no whole-document
+ * regex). Only a strict two-column row (exactly 3 `|` chars, starting the
+ * line, ending the line after trailing space/tab is stripped) is considered;
+ * this is what makes a 3-column row or an unescaped-pipe-bearing value cell
+ * fail to match, mirroring the previous regex's behaviour. Separator rows
+ * (`| --- | --- |`) are skipped, not matched. The match is case-insensitive.
+ * A line terminator is `\r\n`, a lone `\r`, or a lone `\n` — matching the `m`
+ * flag semantics of the regex this function replaced. Returns the byte range
+ * of the value cell (after trimming surrounding space/tab) so the caller can
+ * splice it directly.
+ */
+function locateFieldRow(content, fieldName) {
+    let lineStart = 0;
+    while (lineStart <= content.length) {
+        // A line terminator is `\r\n`, a lone `\r`, or a lone `\n` (JS treats a
+        // bare `\r` as a line terminator too — the regex this replaced used the
+        // `m` flag, which honors all three). Scan for whichever of `\r`/`\n`
+        // occurs first; if it's `\r` immediately followed by `\n`, the terminator
+        // is 2 chars wide, otherwise 1.
+        let terminatorIndex = -1;
+        let terminatorLength = 0;
+        for (let i = lineStart; i < content.length; i++) {
+            const ch = content[i];
+            if (ch === '\n') {
+                terminatorIndex = i;
+                terminatorLength = 1;
+                break;
+            }
+            if (ch === '\r') {
+                terminatorIndex = i;
+                terminatorLength = content[i + 1] === '\n' ? 2 : 1;
+                break;
+            }
+        }
+        const lineEnd = terminatorIndex === -1 ? content.length : terminatorIndex;
+        const line = content.slice(lineStart, lineEnd);
+        if (line.startsWith('|')) {
+            const pipeCount = (line.match(/\|/g) || []).length;
+            const trimmedEnd = line.replace(/[ \t]+$/, '');
+            if (pipeCount === 3 && trimmedEnd.endsWith('|')) {
+                const cells = (0, markdown_table_cjs_1.splitTableRow)(line);
+                if (cells.length === 2 && !isTableSeparatorRow(cells[0])) {
+                    // Line has exactly 3 pipes (enforced above): opening pipe, the
+                    // field/value separator pipe, and the row-closing pipe.
+                    const fieldValueSeparatorPipe = line.indexOf('|', line.indexOf('|') + 1);
+                    const rawCell = line.slice(1, fieldValueSeparatorPipe);
+                    if (fieldNameMatchesRawCell(fieldName, rawCell)) {
+                        const rowClosingPipe = line.indexOf('|', fieldValueSeparatorPipe + 1);
+                        let valueStart = lineStart + fieldValueSeparatorPipe + 1;
+                        while (content[valueStart] === ' ' || content[valueStart] === '\t')
+                            valueStart++;
+                        let valueEnd = lineStart + rowClosingPipe;
+                        while (valueEnd - 1 >= valueStart && (content[valueEnd - 1] === ' ' || content[valueEnd - 1] === '\t'))
+                            valueEnd--;
+                        return { valueStart, valueEnd, rawValue: content.slice(valueStart, valueEnd) };
+                    }
+                }
+            }
+        }
+        if (terminatorIndex === -1)
+            break;
+        lineStart = terminatorIndex + terminatorLength;
+    }
+    return null;
 }
 function stateExtractField(content, fieldName) {
     const escaped = escapeRegex(fieldName);
@@ -71,9 +217,9 @@ function stateExtractField(content, fieldName) {
         return plainMatch[1].trim();
     // Pipe-table format: | FieldName | value |
     // (Separator rows such as `| --- | --- |` are excluded.)
-    const tableMatch = content.match(tableRowPattern(escaped));
-    if (tableMatch && !isTableSeparatorRow(tableMatch[2]))
-        return tableMatch[4].trim();
+    const hit = locateFieldRow(content, fieldName);
+    if (hit)
+        return hit.rawValue.trim();
     return null;
 }
 function stateReplaceField(content, fieldName, newValue) {
@@ -90,11 +236,9 @@ function stateReplaceField(content, fieldName, newValue) {
     }
     // Pipe-table format: | FieldName | value |
     // Preserve the surrounding pipe/whitespace structure; only swap the value cell.
-    const tblPat = tableRowPattern(escaped);
-    const tblMatch = content.match(tblPat);
-    if (tblMatch && !isTableSeparatorRow(tblMatch[2])) {
-        // Reconstruct the row, preserving the original surrounding whitespace/pipes.
-        return content.replace(tblPat, (_m, leadPipe, fieldCell, midPipe, _oldVal, trailPipe) => `${leadPipe}${fieldCell}${midPipe}${newValue}${trailPipe}`);
+    const hit = locateFieldRow(content, fieldName);
+    if (hit) {
+        return content.slice(0, hit.valueStart) + newValue + content.slice(hit.valueEnd);
     }
     return null;
 }
@@ -153,11 +297,14 @@ function shouldPreserveExistingProgress(existingProgress, derivedProgress) {
         return false;
     const existing = existingProgress;
     const derived = derivedProgress;
-    // total_phases is intentionally excluded from the ratchet: it must always
-    // take the freshly derived value so it can correct downward (#1446).
-    // Only completed_phases, total_plans, and completed_plans keep ratchet behaviour.
+    // total_phases (#1446) and total_plans (#2440) are intentionally excluded
+    // from the ratchet: both must always take the freshly derived value so they
+    // can correct in BOTH directions. total_plans legitimately moves up (a new
+    // phase adds plans) and down (milestone reorganization removes phases).
+    // Ratcheting it freezes stale values. Only completed_phases and
+    // completed_plans keep ratchet behaviour — they are monotonic (once a
+    // phase/plan is complete, it stays complete).
     return (existingProgressExceedsDerived(existing, derived, 'completed_phases') ||
-        existingProgressExceedsDerived(existing, derived, 'total_plans') ||
         existingProgressExceedsDerived(existing, derived, 'completed_plans'));
 }
 function normalizeProgressNumbers(progress) {