@opengsd/gsd-core 1.8.0 → 1.9.0

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;
 }

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

@@ -241,7 +241,7 @@ function beginPhaseCore(content, intent, deps) {
     // #1255: body-field replacements operate on body only (frontmatter stripped),
     // not on the full content. The YAML `status:` key matches `^Status:\s*`
     // before the body pipe-table row if full content is passed.
-    const existingFm = extractFrontmatter(content);
+    const existingFm = extractFrontmatter(content, deps.sourcePath);
     const hasFrontmatter = Object.keys(existingFm).length > 0;
     let body = stripFrontmatter(content);
     const reassemble = (b) => hasFrontmatter
@@ -314,7 +314,11 @@ function beginPhaseCore(content, intent, deps) {
         // (do not touch Plan:, Phase:, Status:, stopped_at, progress.percent).
         body = mutateCurrentPositionResume(body, intent, today, updated);
     }
-    return { content: reassemble(body), updated };
+    // #2736: surface the #3127 resume decision so the adapter can drop its
+    // intent-first current_phase_name override on a resume — the core just
+    // preserved the mid-flight name, and an override would drift frontmatter
+    // away from the preserved body value.
+    return { content: reassemble(body), updated, data: { resumed: isAlreadyExecuting } };
 }
 /**
  * Find the `## Current Position` section, return its `{start, end}` byte
@@ -523,7 +527,7 @@ function advancePlanCore(content, deps) {
     // not on the full content. The YAML `status:` key matches `^Status:\s*`
     // before the body field if full content is passed (codex Phase 2 review:
     // HIGH blocking finding — same pattern beginPhaseCore already handles).
-    const existingFm = extractFrontmatter(content);
+    const existingFm = extractFrontmatter(content, deps.sourcePath);
     const hasFrontmatter = Object.keys(existingFm).length > 0;
     let body = stripFrontmatter(content);
     const reassemble = (b) => hasFrontmatter
@@ -645,7 +649,7 @@ function completePhaseCore(content, intent, deps) {
     }
     // #1255: body-field replacements operate on body only (frontmatter stripped),
     // so the YAML `status:` / `current_phase:` keys cannot shadow the body fields.
-    const existingFm = extractFrontmatter(content);
+    const existingFm = extractFrontmatter(content, deps.sourcePath);
     const hasFrontmatter = Object.keys(existingFm).length > 0;
     let body = stripFrontmatter(content);
     const reassemble = (b) => hasFrontmatter
@@ -789,7 +793,7 @@ function plannedPhaseCore(content, intent, deps) {
         }
     }
     // #1255: body-field replacements operate on body only.
-    const existingFm = extractFrontmatter(content);
+    const existingFm = extractFrontmatter(content, deps.sourcePath);
     const hasFrontmatter = Object.keys(existingFm).length > 0;
     let body = stripFrontmatter(content);
     const reassemble = (b) => hasFrontmatter
@@ -831,6 +835,18 @@ function plannedPhaseCore(content, intent, deps) {
     }, statusDefaults, lastActivityDefaults);
     if (body !== beforePos)
         updated.push('Current Position');
+    // #2400 Bug B: sync progress.total_plans to the frontmatter when a plan count
+    // is given. This writes the explicitly-provided count — it is NOT a re-derivation
+    // from disk (#500 RC1 is about deriving from a half-planned snapshot, not about
+    // refusing to write an explicitly-passed argument).
+    if (intent.planCount !== null && intent.planCount !== undefined && hasFrontmatter) {
+        const fmProgress = existingFm['progress'] || {};
+        if (fmProgress['total_plans'] !== intent.planCount) {
+            fmProgress['total_plans'] = intent.planCount;
+            existingFm['progress'] = fmProgress;
+            updated.push('progress.total_plans');
+        }
+    }
     return { content: reassemble(body), updated };
 }
 // ----------------------------------------------------------------------------
@@ -868,7 +884,7 @@ function milestoneSwitchCore(content, intent, deps) {
         'progress',
         'Current Position',
     ];
-    const existingFm = extractFrontmatter(content);
+    const existingFm = extractFrontmatter(content, deps.sourcePath);
     const body = stripFrontmatter(content);
     const resolvedName = (intent.name && intent.name.trim()) || 'milestone';
     // ## Current Position reset body (mirrors state.cts:2371-2375).
@@ -1013,7 +1029,7 @@ function milestoneCompleteCore(content, intent, deps) {
         }
     }
     // #1255: body-field replacements operate on body only.
-    const existingFm = extractFrontmatter(content);
+    const existingFm = extractFrontmatter(content, deps.sourcePath);
     const hasFrontmatter = Object.keys(existingFm).length > 0;
     let body = stripFrontmatter(content);
     const reassemble = (b) => hasFrontmatter
@@ -1339,7 +1355,9 @@ function rebuildCore(content, _intent, deps) {
     let modified = content;
     // §2 Decision: re-derive derived sections, preserve others. Order is
     // oldest-section-first so log entries appear in body order.
-    modified = reconcileCurrentPosition(modified, timestamp, log);
+    // sourcePath threaded so `state rebuild --dry-run` names the file: that branch reads STATE.md
+    // directly rather than through readModifyWriteStateMd, so nothing upstream has named it yet.
+    modified = reconcileCurrentPosition(modified, timestamp, log, deps.sourcePath);
     modified = reconcileByPhaseTable(modified, deps, timestamp, log);
     modified = stripTemplatePlaceholders(modified, timestamp, log);
     modified = deduplicateSessionArchive(modified, timestamp, log);
@@ -1373,8 +1391,8 @@ function rebuildCore(content, _intent, deps) {
  * the key (Leaky-Abstractions guard — don't synthesize values the canonical
  * source doesn't have).
  */
-function reconcileCurrentPosition(content, timestamp, log) {
-    const fm = extractFrontmatter(content);
+function reconcileCurrentPosition(content, timestamp, log, sourcePath) {
+    const fm = extractFrontmatter(content, sourcePath);
     if (!fm || typeof fm !== 'object')
         return content;
     let modified = content;