@remnic/core 9.3.725 → 9.3.727

package/src/compat/codex-subpath-aliases.test.ts

@@ -0,0 +1,93 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+
+import * as canonicalCliFallback from "../cli-fallback.js";
+import * as canonicalThreadKey from "../thread-key.js";
+import * as aliasCliFallback from "./codex-cli-fallback.js";
+import * as aliasThreadKey from "./codex-thread-key.js";
+
+const pkgJsonPath = fileURLToPath(new URL("../../package.json", import.meta.url));
+
+test("codex-cli-fallback alias re-exports the same value symbols as cli-fallback", () => {
+  // export * forwards live bindings by reference, so the function objects and
+  // the test-hooks namespace are identical (===) across both subpaths.
+  assert.equal(
+    aliasCliFallback.callCodexCliFallback,
+    canonicalCliFallback.callCodexCliFallback,
+  );
+  assert.equal(
+    aliasCliFallback.setCodexCliFallbackRunnerForProcess,
+    canonicalCliFallback.setCodexCliFallbackRunnerForProcess,
+  );
+  assert.equal(
+    aliasCliFallback.__codexCliFallbackTestHooks,
+    canonicalCliFallback.__codexCliFallbackTestHooks,
+  );
+});
+
+test("codex-thread-key alias re-exports the same symbol as thread-key", () => {
+  assert.equal(
+    aliasThreadKey.CODEX_THREAD_KEY_PREFIX,
+    canonicalThreadKey.CODEX_THREAD_KEY_PREFIX,
+  );
+  assert.equal(aliasThreadKey.CODEX_THREAD_KEY_PREFIX, "codex-thread:");
+});
+
+test("every named runtime export of cli-fallback is forwarded by the alias", () => {
+  for (const key of Object.keys(canonicalCliFallback)) {
+    assert.equal(
+      key in aliasCliFallback,
+      true,
+      `alias missing forwarded export: ${key}`,
+    );
+  }
+});
+
+test("importing the old subpath resolves to the same symbol as the new subpath", async () => {
+  // @remnic/core self-references its own exports map. Under --conditions=
+  // remnic-source (set by preflight/test NODE_OPTIONS) the subpaths resolve to
+  // src/. Both specifiers land on the same module record, so the exported
+  // function is the same object reference.
+  const [byNew, byOld] = await Promise.all([
+    import("@remnic/core/cli-fallback"),
+    import("@remnic/core/codex-cli-fallback"),
+  ]);
+  assert.equal(byOld.callCodexCliFallback, byNew.callCodexCliFallback);
+
+  const [newKey, oldKey] = await Promise.all([
+    import("@remnic/core/thread-key"),
+    import("@remnic/core/codex-thread-key"),
+  ]);
+  assert.equal(oldKey.CODEX_THREAD_KEY_PREFIX, newKey.CODEX_THREAD_KEY_PREFIX);
+});
+
+test("the deprecated subpaths are registered with a removal timeline in the exports map", () => {
+  const pkg = JSON.parse(readFileSync(pkgJsonPath, "utf8")) as {
+    exports: Record<string, { deprecated?: string; import?: string }>;
+  };
+  const aliasEntries = [
+    "./codex-cli-fallback",
+    "./codex-cli-fallback.js",
+    "./codex-thread-key",
+    "./codex-thread-key.js",
+  ];
+  for (const subpath of aliasEntries) {
+    const entry = pkg.exports[subpath];
+    assert.ok(entry, `missing exports entry for ${subpath}`);
+    assert.ok(
+      entry.deprecated,
+      `exports entry for ${subpath} missing a deprecated field`,
+    );
+    assert.match(
+      entry.deprecated,
+      /v?10\.0\.0|remov/i,
+      `deprecated field for ${subpath} should state a removal timeline`,
+    );
+    assert.ok(
+      entry.import?.includes("/compat/"),
+      `exports entry for ${subpath} should target the compat re-export module`,
+    );
+  }
+});

package/src/compat/codex-thread-key.ts

@@ -0,0 +1,23 @@
+/**
+ * Deprecated alias subpath `@remnic/core/codex-thread-key`.
+ *
+ * PR #1638 renamed `src/codex-thread-key.ts` -> `src/thread-key.ts` to
+ * graduate the host-prefixed name per CLAUDE.md rule 31. This thin re-export
+ * keeps the old subpath resolving during the compat window so external
+ * consumers importing `@remnic/core/codex-thread-key` do not hit
+ * ERR_PACKAGE_PATH_NOT_EXPORTED. It forwards every export to the canonical
+ * module -- no logic is duplicated.
+ *
+ * Removal timeline: v10.0.0 (see issue #1643).
+ * Import from `@remnic/core/thread-key` instead.
+ */
+export * from "../thread-key.js";
+
+process.emitWarning(
+  "@remnic/core/codex-thread-key is a deprecated alias; import from @remnic/core/thread-key instead. Removed in v10.0.0 (issue #1643).",
+  {
+    type: "DeprecationWarning",
+    code: "REMNIC_DEP_CORE_SUBPATH_CODEX_THREAD_KEY",
+    detail: "PR #1638 renamed codex-thread-key.ts to thread-key.ts.",
+  },
+);

package/src/config.test.ts

@@ -2092,3 +2092,53 @@ test("parseConfig rejects invalid correction.enabled instead of silently enablin
   assert.equal(parseConfig({ correctionEnabled: "0" }).correctionEnabled, false);
   assert.equal(parseConfig({}).correctionEnabled, true);
 });
+
+test("parseConfig rejects invalid correction.planTtlHours instead of silently defaulting (#1678)", () => {
+  // Nested form: correction.planTtlHours.
+  for (const value of [0, -1, 0.5, "0", "-5", "abc", true, null]) {
+    assert.throws(
+      () => parseConfig({ correction: { planTtlHours: value } } as Record<string, unknown>),
+      /Invalid correction\.planTtlHours/,
+      `nested planTtlHours=${JSON.stringify(value)} should throw`,
+    );
+  }
+  // Flat form: correctionPlanTtlHours.
+  for (const value of [0, -3, "abc", true]) {
+    assert.throws(
+      () => parseConfig({ correctionPlanTtlHours: value } as Record<string, unknown>),
+      /Invalid correction\.planTtlHours/,
+      `flat correctionPlanTtlHours=${JSON.stringify(value)} should throw`,
+    );
+  }
+  // Valid values resolve (no regression on the happy path).
+  assert.equal(parseConfig({ correction: { planTtlHours: 48 } }).correctionPlanTtlHours, 48);
+  assert.equal(parseConfig({ correctionPlanTtlHours: 12 }).correctionPlanTtlHours, 12);
+  assert.equal(parseConfig({}).correctionPlanTtlHours, 24, "absent → documented default");
+});
+
+test("parseConfig correction.maxAffected rejects non-integers (Number.isInteger, #1678)", () => {
+  // The error message says "integer" — 3.7 must be rejected, not silently floored to 3.
+  for (const value of [3.7, 2.5, "1.5", 0.99]) {
+    assert.throws(
+      () => parseConfig({ correction: { maxAffected: value } } as Record<string, unknown>),
+      /Invalid correction\.maxAffected/,
+      `maxAffected=${JSON.stringify(value)} should throw (non-integer)`,
+    );
+  }
+  for (const value of [0, -1, "abc"]) {
+    assert.throws(
+      () => parseConfig({ correction: { maxAffected: value } } as Record<string, unknown>),
+      /Invalid correction\.maxAffected/,
+      `maxAffected=${JSON.stringify(value)} should throw`,
+    );
+  }
+  // Flat form.
+  assert.throws(
+    () => parseConfig({ correctionMaxAffected: 4.2 } as Record<string, unknown>),
+    /Invalid correction\.maxAffected/,
+  );
+  // Valid integers resolve.
+  assert.equal(parseConfig({ correction: { maxAffected: 5 } }).correctionMaxAffected, 5);
+  assert.equal(parseConfig({ correctionMaxAffected: 20 }).correctionMaxAffected, 20);
+  assert.equal(parseConfig({}).correctionMaxAffected, 10, "absent → documented default");
+});

package/src/config.ts

@@ -2130,17 +2130,34 @@ export function parseConfig(
       const raw = rawNested !== undefined ? rawNested : cfg.correctionMaxAffected;
       if (raw === undefined || raw === null) return 10;
       const n = coerceNumber(raw);
-      if (n === undefined || !Number.isFinite(n) || n < 1) {
+      // #1678 (thread Oiup6): the error message says "integer" — enforce it
+      // with Number.isInteger so 3.7 is rejected rather than silently floored.
+      if (n === undefined || !Number.isFinite(n) || n < 1 || !Number.isInteger(n)) {
         throw new Error(`Invalid correction.maxAffected: expected an integer >= 1, got ${JSON.stringify(raw)}`);
       }
-      return Math.floor(n);
+      return n;
     })(),
     correctionPlanTtlHours: (() => {
       const nested = (cfg.correction as Record<string, unknown> | undefined)?.planTtlHours;
       const fromNested = nested !== undefined ? coerceNumber(nested) : undefined;
-      if (fromNested !== undefined && fromNested > 0) return fromNested;
+      if (fromNested !== undefined && fromNested >= 1) return fromNested;
+      // #1678 (threads Ohtvi/Ohyvf): reject invalid (0/negative/non-numeric)
+      // instead of silently defaulting to 24h — completes the config-reject
+      // class already enforced for enabled/applyRequiresConfirm/maxAffected.
+      if (nested !== undefined && fromNested === undefined) {
+        throw new Error(`Invalid correction.planTtlHours: expected a number >= 1, got ${JSON.stringify(nested)}`);
+      }
+      if (fromNested !== undefined && fromNested < 1) {
+        throw new Error(`Invalid correction.planTtlHours: expected a number >= 1, got ${JSON.stringify(nested)}`);
+      }
       const fromFlat = coerceNumber(cfg.correctionPlanTtlHours);
-      if (fromFlat !== undefined && fromFlat > 0) return fromFlat;
+      if (fromFlat !== undefined && fromFlat >= 1) return fromFlat;
+      if (cfg.correctionPlanTtlHours !== undefined && fromFlat === undefined) {
+        throw new Error(`Invalid correction.planTtlHours: expected a number >= 1, got ${JSON.stringify(cfg.correctionPlanTtlHours)}`);
+      }
+      if (fromFlat !== undefined && fromFlat < 1) {
+        throw new Error(`Invalid correction.planTtlHours: expected a number >= 1, got ${JSON.stringify(cfg.correctionPlanTtlHours)}`);
+      }
       return 24;
     })(),
     // Passive correction capture (issue #1581). Parsed from

package/src/content-hash.ts

@@ -0,0 +1,24 @@
+/**
+ * content-hash.ts — standalone content normalization + SHA-256 hashing.
+ *
+ * Extracted from `ContentHashIndex` (storage.ts) so correction modules and
+ * other consumers can hash content WITHOUT importing the storage god file
+ * (issue #1533 directStorageImports ratchet). The static methods on
+ * `ContentHashIndex` delegate here to guarantee identical results.
+ */
+
+import { createHash } from "node:crypto";
+
+/** Normalize content: lowercase, strip non-alphanumerics, collapse whitespace. */
+export function normalizeContent(content: string): string {
+  return content
+    .toLowerCase()
+    .replace(/[^a-z0-9\s]/g, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+/** Normalize content and compute SHA-256 hash. */
+export function computeContentHash(content: string): string {
+  return createHash("sha256").update(normalizeContent(content)).digest("hex");
+}

package/src/correction/correction-access-wiring.ts

@@ -21,10 +21,14 @@
  */
 
 import path from "node:path";
+import { createHash } from "node:crypto";
 import { mkdir, writeFile } from "node:fs/promises";
 import type { Orchestrator } from "../orchestrator.js";
 import type { MemoryFile, MemoryStatus, PluginConfig } from "../types.js";
 import { stripAttributesSuffix } from "../structured-attributes.js";
+import { supersessionKeysForFact } from "../temporal-supersession.js";
+import { computeContentHash } from "../content-hash.js";
+import { sanitizeMemoryContent } from "../sanitize.js";
 import {
   CorrectionContractError,
   validateCorrectionAction,
@@ -168,7 +172,7 @@ async function searchMemories(
     const storage = await wiring.orchestrator.getStorage(ns);
     const all = await storage.readAllMemories();
     for (const m of all) {
-      if (m.frontmatter.status && m.frontmatter.status !== "active") continue;
+      if (!isEligibleCorrectionCandidate(m)) continue;
       const hay = `${m.content} ${m.frontmatter.tags?.join(" ") ?? ""}`.toLowerCase();
       let hits = 0;
       for (const tok of tokens) {
@@ -265,7 +269,7 @@ async function expandEntityNeighbors(
     for (const m of all) {
       if (out.length >= limit) break;
       if (seen.has(m.frontmatter.id)) continue;
-      if (m.frontmatter.status && m.frontmatter.status !== "active") continue;
+      if (!isEligibleCorrectionCandidate(m)) continue;
       if (m.frontmatter.entityRef && seedRefs.has(m.frontmatter.entityRef)) {
         out.push(toCandidate(m, ns, 0.5));
         seen.add(m.frontmatter.id);
@@ -427,9 +431,22 @@ async function applyEditMemory(
   // The StorageManager's writeMemoryFrontmatter snapshots the prior version
   // internally when page-versioning is configured (issue #371), so every edit
   // is revertable without the correction layer forking versioning logic.
+  //
+  // #1672 item 3: recompute the contentHash from the patched body so the
+  // dedup index + tombstone exact tier match the NEW content. writeMemory
+  // computes this at write time, but writeMemoryFrontmatter preserves the
+  // prior frontmatter hash — without this the hash no longer matches the
+  // patched body and a later re-extraction of the same fact dedup-misses.
+  const contentHashForPatch =
+    existing.frontmatter.category === "fact"
+      ? computeContentHash(sanitizeMemoryContent(patch).text)
+      : undefined;
   await storage.writeMemoryFrontmatter(
     { ...existing, content: patch },
-    { updated: new Date().toISOString() },
+    {
+      updated: new Date().toISOString(),
+      ...(contentHashForPatch ? { contentHash: contentHashForPatch } : {}),
+    },
   );
   return memoryId;
 }
@@ -535,6 +552,8 @@ async function appendTombstoneFn(
     rawContent: string;
     entityRef?: string;
     supersessionKey?: string;
+    supersessionKeys?: string[];
+    contentHash?: string;
   },
 ): Promise<string | null> {
   const storage = await wiring.orchestrator.getStorage(namespace);
@@ -550,20 +569,46 @@ async function appendTombstoneFn(
     typeof storage.isTombstonesEnabled === "function"
       ? storage.isTombstonesEnabled()
       : true;
-  const result = await storage.appendTombstone({
-    reason: input.reason,
-    createdBy: "user_correction",
-    sourceMemoryId: input.sourceMemoryId,
-    rawContent: input.rawContent,
-    ...(input.entityRef ? { entityRef: input.entityRef } : {}),
-    ...(input.supersessionKey ? { supersessionKey: input.supersessionKey } : {}),
-  });
-  if (result === null && enabled) {
-    throw new CorrectionContractError(
-      `tombstone persistence failed for memory ${input.sourceMemoryId} (tombstones enabled but store returned null — I/O error swallowed)`,
-    );
+  // #1672 item 4: emit one tombstone per derived supersession key (mirrors
+  // temporal-supersession / forget / pattern-reinforcement) so a paraphrased
+  // re-observation placing the attribute at a different key position is still
+  // blocked at the keyed tier. When no keys are derived, emit a single
+  // content-only tombstone. Each carries the canonical contentHash so the
+  // exact tier also matches re-extraction.
+  const keys =
+    input.supersessionKeys && input.supersessionKeys.length > 0
+      ? input.supersessionKeys
+      : input.supersessionKey
+        ? [input.supersessionKey]
+        : [undefined];
+  const writtenIds: string[] = [];
+  let firstId: string | null = null;
+  for (const key of keys) {
+    const result = await storage.appendTombstone({
+      reason: input.reason,
+      createdBy: "user_correction",
+      sourceMemoryId: input.sourceMemoryId,
+      rawContent: input.rawContent,
+      ...(input.entityRef ? { entityRef: input.entityRef } : {}),
+      ...(key ? { supersessionKey: key } : {}),
+      ...(input.contentHash ? { contentHash: input.contentHash } : {}),
+    });
+    if (result === null && enabled) {
+      // Rollback already-written tombstones so a partial multi-key failure
+      // does not leave incomplete resurrection blocking for the still-active
+      // memory (review thread #1). Best-effort — a dangling tombstone is the
+      // safer failure mode (false-positive block vs. false-negative leak).
+      for (const id of writtenIds) {
+        try { await storage.revokeTombstone(id, "user_correction"); } catch { /* best-effort */ }
+      }
+      throw new CorrectionContractError(
+        `tombstone persistence failed for memory ${input.sourceMemoryId} (tombstones enabled but store returned null — I/O error swallowed)`,
+      );
+    }
+    if (firstId === null) firstId = result;
+    if (result) writtenIds.push(result);
   }
-  return result;
+  return firstId;
 }
 
 async function registerRedactionRuleFn(
@@ -576,9 +621,14 @@ async function registerRedactionRuleFn(
   const storage = await wiring.orchestrator.getStorage(namespace);
   const dir = path.join(storage.dir, "state", "corrections", "redaction-rules");
   await mkdir(dir, { recursive: true });
-  // Idempotent: filename is a slug of the pattern so re-registering the same
-  // pattern overwrites rather than duplicates.
-  const slug = pattern.replace(/[^a-zA-Z0-9]+/g, "-").slice(0, 64) || "rule";
+  // Idempotent: filename is a slug + short hash of the full pattern so
+  // re-registering the same pattern overwrites rather than duplicates, while
+  // distinct patterns that slug identically (e.g. "abc+def" vs "abc.def" →
+  // "abc-def") no longer collide and silently remove each other's enforcement
+  // (review thread P1).
+  const slugBase = pattern.replace(/[^a-zA-Z0-9]+/g, "-").slice(0, 48) || "rule";
+  const patternHash = createHash("sha256").update(pattern).digest("hex").slice(0, 16);
+  const slug = `${slugBase}-${patternHash}`;
   await writeFile(
     path.join(dir, `${slug}.json`),
     `${JSON.stringify({ pattern, namespace, createdAt: new Date().toISOString() })}\n`,
@@ -686,6 +736,22 @@ function toCandidate(m: MemoryFile, namespace: string, score: number): PlannerCa
   } satisfies PlannerCandidate & { namespace?: string };
 }
 
+/**
+ * Lifecycle-aware eligibility for a correction candidate (#1672 item 2). A
+ * memory is eligible only when it is `status: "active"` AND not archived.
+ * Planning a correction against a memory that was archived via the
+ * `archivedAt`/archive path but still marked active would surface stale
+ * content the user already set aside — and apply would reject the rescope
+ * (non-active source) or supersede a fact the user intended gone. Both the
+ * status flip and the archive timestamp are checked so the candidate set
+ * stays consistent with the rescope/retire apply-time guards.
+ */
+function isEligibleCorrectionCandidate(m: MemoryFile): boolean {
+  if (m.frontmatter.status && m.frontmatter.status !== "active") return false;
+  if (typeof m.frontmatter.archivedAt === "string" && m.frontmatter.archivedAt.length > 0) return false;
+  return true;
+}
+
 function toExecutorMemory(m: MemoryFile): ExecutorMemory {
   const fm = m.frontmatter;
   // The tombstone hash must use the ORIGINAL unsuffixed body: writeMemory
@@ -693,12 +759,27 @@ function toExecutorMemory(m: MemoryFile): ExecutorMemory {
   // hashing m.content would never match the pre-suffix content hash (thread
   // OhX2N, rule 23). Strip the suffix when attributes are present.
   const rawBody = fm.structuredAttributes ? stripAttributesSuffix(m.content) : m.content;
+  // #1672 item 4: derive the full supersession-key set from the memory's
+  // structuredAttributes so the tombstone's keyed tier blocks paraphrased
+  // re-observations that place the attribute at a different key position
+  // (mirrors temporal-supersession's per-key emission). Also forward the
+  // canonical contentHash so the exact tier matches re-extraction without
+  // recomputing from a citation-annotated body.
+  const supersessionKeys = supersessionKeysForFact({
+    entityRef: fm.entityRef,
+    structuredAttributes: fm.structuredAttributes,
+  });
   return {
     memoryId: fm.id,
     content: m.content,
     category: fm.category,
     rawContent: rawBody,
     ...(fm.entityRef ? { entityRef: fm.entityRef } : {}),
+    ...(supersessionKeys.length > 0 ? { supersessionKeys } : {}),
+    ...(supersessionKeys.length > 0 ? { supersessionKey: supersessionKeys[0] } : {}),
+    ...(typeof fm.contentHash === "string" && fm.contentHash.length > 0
+      ? { contentHash: fm.contentHash }
+      : {}),
   } satisfies ExecutorMemory;
 }
 
@@ -884,4 +965,8 @@ export {
   buildClassifyPrompt,
   CLASSIFY_SYSTEM_PROMPT,
   parseClassifyResponse,
+  // #1672: exported for focused storage-integration regression tests.
+  isEligibleCorrectionCandidate,
+  applyEditMemory,
+  appendTombstoneFn,
 };

package/src/correction/correction-contract.ts

@@ -263,25 +263,50 @@ export function validateRedactionPattern(pattern: string): string {
       `redaction_rule.pattern exceeds the ${REDACTION_PATTERN_MAX}-character bound.`,
     );
   }
-  // Reject patterns that could match an unbounded string (catastrophic /
-  // overly-broad). A literal or a bounded regex is fine; a bare `.*` / `.`
-  // regex is not. We do NOT execute the regex (ReDoS); we only inspect shape.
-  if (isRegexLike(trimmed) && isOverlyBroadRegex(trimmed)) {
+  // Reject patterns that could match an unbounded string (overly-broad) OR
+  // exhibit catastrophic backtracking (nested quantifiers like `(a+)+`). We do
+  // NOT execute the regex (that would be ReDoS itself); we only inspect shape.
+  if (isRegexLike(trimmed) && isUnsafeRedactionRegex(trimmed)) {
     throw new CorrectionContractError(
-      "redaction_rule.pattern is too broad — use a bounded literal or a more specific pattern.",
+      "redaction_rule.pattern is unsafe — use a bounded literal or a regex without nested quantifiers / overlapping alternation.",
     );
   }
+  // #1669 P2: reject zero-width regex (empty body or matches empty string)
+  // that would withhold every fact.
+  if (isRegexLike(trimmed)) {
+    const regexBody = trimmed.slice(1, -1);
+    if (regexBody.length === 0) {
+      throw new CorrectionContractError("redaction_rule.pattern body is empty — use a non-empty regex.");
+    }
+    try {
+      if (new RegExp(regexBody).test("")) {
+        throw new CorrectionContractError(
+          "redaction_rule.pattern matches the empty string — it would withhold every fact.",
+        );
+      }
+    } catch (e) {
+      if (e instanceof CorrectionContractError) throw e;
+      // Compilation failed — the extraction-time defense handles it.
+    }
+  }
   return trimmed;
 }
 
-/** Heuristic: treat `/.../` or presence of regex metacharacters as regex. */
+/** Only `/.../`-wrapped patterns are treated as regex; everything else is a
+ *  literal (review thread P1 — consistent with extraction-redaction-rules.ts). */
 function isRegexLike(pattern: string): boolean {
-  if (pattern.startsWith("/") && pattern.endsWith("/") && pattern.length >= 2) return true;
-  return /[\\^$.|?*+()[\]{}]/.test(pattern);
+  return pattern.startsWith("/") && pattern.endsWith("/") && pattern.length >= 2;
 }
 
-/** Reject a regex that would match an arbitrary-length run of any character. */
-function isOverlyBroadRegex(pattern: string): boolean {
+/**
+ * Reject a regex that would either match an arbitrary-length run of any
+ * character (overly-broad) OR exhibit catastrophic backtracking (ReDoS).
+ * Mirrors the safe-regex heuristic in extraction-redaction-rules.ts so the
+ * apply-time chokepoint and the extraction-time defense agree on what is
+ * pathological — intentionally not imported to keep the two modules decoupled
+ * (contract owns validation; extraction owns consultation).
+ */
+function isUnsafeRedactionRegex(pattern: string): boolean {
   const body = pattern.startsWith("/") && pattern.endsWith("/")
     ? pattern.slice(1, -1)
     : pattern;
@@ -289,6 +314,39 @@ function isOverlyBroadRegex(pattern: string): boolean {
   if (/(?:^|[^\\])\(\.\*\)|(?:^|[^\\])\.\*|(?:^|[^\\])\.\+|^\.([^*+]?)$/.test(body)) {
     return true;
   }
+  // Nested quantifier: a group (...) whose body ends with a quantifier and
+  // which is itself quantified → exponential blowup on near-miss inputs
+  // (classic ReDoS shapes: (a+)+, (a*)*, (a?)+). Also catches overlapping
+  // alternation under repetition: (a|a)+ where branches share a prefix.
+  if (body.length > 512) return true;
+  for (let i = 0; i < body.length; i++) {
+    if (body[i] !== "(") continue;
+    let depth = 1;
+    let j = i + 1;
+    while (j < body.length && depth > 0) {
+      if (body[j] === "\\") { j += 2; continue; }
+      if (body[j] === "(") depth++;
+      else if (body[j] === ")") depth--;
+      j++;
+    }
+    if (depth !== 0) continue;
+    const afterGroup = body[j];
+    if (afterGroup !== "+" && afterGroup !== "*" && afterGroup !== "{") continue;
+    const groupBody = body.slice(i + 1, j - 1);
+    if (/[+*?]$/.test(groupBody) || /\{\d+,?\d*\}[+*?]?$/.test(groupBody)) {
+      return true;
+    }
+    if (groupBody.includes("|")) {
+      const branches = groupBody.split("|");
+      if (branches.length >= 2) {
+        const firstChars = new Set(branches.map((b) => b[0]).filter(Boolean));
+        if (firstChars.size < branches.filter((b) => b.length > 0).length) {
+          return true;
+        }
+      }
+    }
+    i = j;
+  }
   return false;
 }