sdd-agent-platform 0.4.1 → 0.4.2

package/node_modules/@sdd-agent-platform/core/src/sdd-docs/document-hashes.ts

@@ -40,12 +40,87 @@ const TOP_LEVEL_CONTRACT_SECTION_TITLES = [
   'Phase Gate Checkpoint'
 ];
 
+const RUNTIME_METADATA_KEYS = new Set([
+  'accepted_status',
+  'close_status',
+  'created_at',
+  'decision_id',
+  'generated_at',
+  'generatedat',
+  'reviewhash',
+  'run_id',
+  'runtime_decision_id',
+  'targethash',
+  'updated_at'
+]);
+
 export function hashDocumentContent(raw: string): string {
-  return sha256(raw.replace(/\r\n/g, '\n'));
+  return sha256(normalizeLineEndings(raw));
+}
+
+export function hashNormalizedMarkdownContent(raw: string | null): string | null {
+  return raw === null ? null : sha256(normalizeMarkdownContentV1(raw));
+}
+
+export function normalizeMarkdownContentV1(raw: string): string {
+  const withoutBom = raw.charCodeAt(0) === 0xFEFF ? raw.slice(1) : raw;
+  let lines = normalizeLineEndings(withoutBom).split('\n');
+  if (lines[0]?.trim() === '---') {
+    const frontmatterEnd = lines.findIndex((line, index) => index > 0 && line.trim() === '---');
+    if (frontmatterEnd > 0) {
+      const frontmatter = lines.slice(1, frontmatterEnd).filter((line) => !isRuntimeMetadataLine(line));
+      lines = [...(frontmatter.some((line) => line.trim()) ? ['---', ...frontmatter, '---'] : []), ...lines.slice(frontmatterEnd + 1)];
+    }
+  }
+
+  const normalized: string[] = [];
+  let fence: { character: '`' | '~'; length: number } | null = null;
+  let previousBlank = false;
+
+  for (const line of lines) {
+    if (fence) {
+      normalized.push(line);
+      if (isClosingFence(line, fence)) {
+        fence = null;
+      }
+      previousBlank = false;
+      continue;
+    }
+
+    const openingFence = parseOpeningFence(line);
+    if (openingFence) {
+      normalized.push(line);
+      fence = openingFence;
+      previousBlank = false;
+      continue;
+    }
+
+    const withoutTrailingWhitespace = line.replace(/[ \t]+$/g, '');
+    if (isStandaloneHtmlComment(withoutTrailingWhitespace) || isRuntimeMetadataLine(withoutTrailingWhitespace)) {
+      continue;
+    }
+    if (withoutTrailingWhitespace.trim() === '') {
+      if (!previousBlank) {
+        normalized.push('');
+        previousBlank = true;
+      }
+      continue;
+    }
+    normalized.push(withoutTrailingWhitespace);
+    previousBlank = false;
+  }
+
+  while (normalized.length > 0 && normalized[0] === '') {
+    normalized.shift();
+  }
+  while (normalized.length > 0 && normalized[normalized.length - 1] === '') {
+    normalized.pop();
+  }
+  return normalized.length > 0 ? `${normalized.join('\n')}\n` : '';
 }
 
 export function hashSemanticDocument(raw: string | null): string | null {
-  return raw === null ? null : sha256(normalizeSemanticMarkdown(raw));
+  return hashNormalizedMarkdownContent(raw);
 }
 
 export function hashTasksContract(raw: string | null): string | null {
@@ -82,14 +157,38 @@ function parseTaskContracts(raw: string): unknown[] {
   }).sort((left, right) => String((left as { id: string | null }).id ?? '').localeCompare(String((right as { id: string | null }).id ?? '')));
 }
 
-function normalizeSemanticMarkdown(raw: string): string {
-  return raw
-    .replace(/\r\n/g, '\n')
-    .split('\n')
-    .filter((line) => !/^\s*(created_at|updated_at|generatedAt|generated_at|run_id):/i.test(line))
-    .map((line) => line.trim())
-    .filter(Boolean)
-    .join('\n');
+function normalizeLineEndings(raw: string): string {
+  return raw.replace(/\r\n?/g, '\n');
+}
+
+function parseOpeningFence(line: string): { character: '`' | '~'; length: number } | null {
+  const match = line.match(/^\s*(`{3,}|~{3,})/);
+  if (!match) {
+    return null;
+  }
+  const marker = match[1];
+  return { character: marker[0] as '`' | '~', length: marker.length };
+}
+
+function isClosingFence(line: string, fence: { character: '`' | '~'; length: number }): boolean {
+  const escaped = fence.character === '`' ? '`' : '~';
+  const match = line.match(new RegExp(`^\\s*(${escaped}{${fence.length},})\\s*$`));
+  return Boolean(match);
+}
+
+function isStandaloneHtmlComment(line: string): boolean {
+  return /^\s*<!--[\s\S]*?-->\s*$/.test(line);
+}
+
+function isRuntimeMetadataLine(line: string): boolean {
+  const match = line.match(/^\s*(?:-\s*)?([A-Za-z0-9_]+):\s*/);
+  if (!match) {
+    return false;
+  }
+  const key = match[1];
+  const normalizedKey = key.toLowerCase();
+  return /^based_on_.*_hash$/.test(normalizedKey)
+    || RUNTIME_METADATA_KEYS.has(normalizedKey);
 }
 
 function normalizeSectionText(value: string | null): string | null {

package/node_modules/@sdd-agent-platform/core/src/sdd-docs/run-binding.ts

@@ -4,7 +4,8 @@ import { readRunState, writeRunState } from '../run-state/run-state.js';
 import type { RunDocumentSnapshot, RunState } from '../run-state/model.js';
 import type { ContextResolverContract } from './context.js';
 import type { SddTask, SddTaskModel } from './task-parser.js';
-import { getEvidenceDir } from '../runtime-paths.js';
+import { getRunEvidenceRoot } from '../runtime-paths.js';
+import { branchToSafePartition } from '../path-safety.js';
 
 export async function bindRunStateToTask(projectRoot: string, state: RunState, context: ContextResolverContract, model: SddTaskModel, task: SddTask | null, taskId: string): Promise<RunState> {
   if (state.partition && state.partition !== context.partition) {
@@ -24,8 +25,8 @@ export async function bindRunStateToTask(projectRoot: string, state: RunState, c
     gitBranch: context.rawBranch,
     taskId,
     affectedFiles: task?.affectedFiles ?? state.affectedFiles,
-    documentSnapshot: documentSnapshotFromModel(model),
-    artifactRoot: path.relative(projectRoot, getEvidenceDir(projectRoot, context.partition))
+    documentSnapshot: documentSnapshotFromModel(model, task),
+    artifactRoot: path.relative(projectRoot, path.join(getRunEvidenceRoot(projectRoot), branchToSafePartition(context.partition)))
   };
   await writeRunState(projectRoot, nextState);
   await appendEvent(projectRoot, state.runId, {
@@ -60,8 +61,8 @@ export async function bindRunStateToTaskContext(projectRoot: string, state: RunS
     partition: context.partition,
     gitBranch: context.rawBranch,
     affectedFiles: [...new Set([...state.affectedFiles, ...(task?.affectedFiles ?? [])])],
-    documentSnapshot: documentSnapshotFromModel(model),
-    artifactRoot: path.relative(projectRoot, getEvidenceDir(projectRoot, context.partition))
+    documentSnapshot: documentSnapshotFromModel(model, task),
+    artifactRoot: path.relative(projectRoot, path.join(getRunEvidenceRoot(projectRoot), branchToSafePartition(context.partition)))
   };
   await writeRunState(projectRoot, nextState);
   await appendEvent(projectRoot, state.runId, {
@@ -79,7 +80,7 @@ export async function bindRunStateToTaskContext(projectRoot: string, state: RunS
   return readRunState(projectRoot, state.runId);
 }
 
-export function documentSnapshotFromModel(model: SddTaskModel): RunDocumentSnapshot {
+export function documentSnapshotFromModel(model: SddTaskModel, task: SddTask | null = null): RunDocumentSnapshot {
   return {
     specHash: model.documents.specHash ?? null,
     planHash: model.documents.planHash ?? null,
@@ -87,6 +88,7 @@ export function documentSnapshotFromModel(model: SddTaskModel): RunDocumentSnaps
     specContractHash: model.documents.specContractHash ?? null,
     planContractHash: model.documents.planContractHash ?? null,
     tasksContractHash: model.documents.tasksContractHash ?? null,
+    taskContractHash: task?.contractHash ?? null,
     planBasedOnSpecHash: model.documents.planBasedOnSpecHash ?? null,
     tasksBasedOnPlanHash: model.documents.tasksBasedOnPlanHash ?? null,
     planBasedOnSpecContractHash: model.documents.planBasedOnSpecContractHash ?? null,

package/node_modules/@sdd-agent-platform/core/src/sdd-docs/task-parser.test.ts

@@ -5,7 +5,7 @@ import { tmpdir } from 'node:os';
 import path from 'node:path';
 
 import { validTaskMarkdown } from '../test-support/fixtures.js';
-import { hashTasksContract } from './document-hashes.js';
+import { hashNormalizedMarkdownContent, hashTasksContract, normalizeMarkdownContentV1 } from './document-hashes.js';
 import { inspectSddTask } from './task-inspection.js';
 import { parseSddBranch, parseSddTasksMarkdown } from './task-parser.js';
 import { renderTaskGapReport } from './task-rendering.js';
@@ -67,6 +67,73 @@ None yet.
   assert.deepEqual(model.tasks[0].acceptance, ['Task metadata is structured.', 'Boundary is retained.']);
 });
 
+test('parseSddTasksMarkdown stops companion sections at level-two task headings', () => {
+  const markdown = `# Tasks
+
+## T1: First task
+
+\`\`\`sdd-task
+id: T1
+status: pending
+wave: 1
+depends_on: []
+affected_files:
+  - packages/app/login.ts
+change_surface: backend_only
+validation_timing: task_end
+requires_verify_before_next: true
+validation:
+  - npm test
+risk: []
+\`\`\`
+
+#### Boundary
+
+Only T1.
+
+#### Acceptance
+
+- T1 passes.
+
+#### Implementation Notes
+
+Keep T1 narrow.
+
+## T2: Second task
+
+T2 introduction must not be parsed as T1 notes.
+
+\`\`\`sdd-task
+id: T2
+status: pending
+wave: 1
+depends_on: [T1]
+affected_files:
+  - packages/core/src/index.ts
+change_surface: backend_only
+validation_timing: task_end
+requires_verify_before_next: true
+validation:
+  - npm test
+risk: []
+\`\`\`
+
+#### Boundary
+
+Only T2.
+
+#### Acceptance
+
+- T2 passes.
+`;
+  const model = parseSddTasksMarkdown(markdown, { tasksPath: 'specs/master/tasks.md' });
+
+  assert.equal(model.gaps.length, 0);
+  assert.equal(model.tasks[0].source.heading, 'T1: First task');
+  assert.equal(model.tasks[0].implementationNotes, 'Keep T1 narrow.');
+  assert.equal(model.tasks[0].implementationNotes?.includes('T2 introduction'), false);
+});
+
 test('parseSddTasksMarkdown blocks backend build validation for frontend-only tasks', () => {
   const markdown = `# Tasks
 
@@ -170,6 +237,61 @@ Stay in parser scope.
   assert.notEqual(hashTasksContract(base), hashTasksContract(changed));
 });
 
+test('normalizeMarkdownContentV1 applies conservative formatting normalization', () => {
+  const base = `---
+contract: sdd-spec-doc-v1
+based_on_spec_hash: legacy
+created_at: 2026-01-01T00:00:00.000Z
+---
+
+# Spec   
+
+<!-- standalone comment -->
+
+- keep list order
+  - keep indentation
+
+\`\`\`md
+<!-- keep fenced comment -->   
+based_on_spec_hash: keep-in-code
+\`\`\`
+`;
+  const equivalent = `---\r\ncontract: sdd-spec-doc-v1\r\nbased_on_spec_hash: changed\r\nupdated_at: 2026-01-02T00:00:00.000Z\r\n---\r\n\r\n# Spec\t\r\n\r\n\r\n<!-- standalone comment -->\r\n\r\n- keep list order\r\n  - keep indentation\r\n\r\n\`\`\`md\r\n<!-- keep fenced comment -->   \r\nbased_on_spec_hash: keep-in-code\r\n\`\`\`\r\n`;
+
+  assert.equal(normalizeMarkdownContentV1(base), normalizeMarkdownContentV1(equivalent));
+  assert.match(normalizeMarkdownContentV1(base), /<!-- keep fenced comment -->   /);
+  assert.doesNotMatch(normalizeMarkdownContentV1(base), /standalone comment/);
+});
+
+test('spec and plan contract hashes ignore runtime metadata and formatting noise only', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'sdd-normalized-contract-hash-'));
+  try {
+    const branchDir = path.join(root, 'specs', 'feature');
+    await mkdir(branchDir, { recursive: true });
+    const spec = '# Spec\n\nInitial requirement.\n';
+    const plan = '# Plan\n\nInitial plan.\n';
+    await writeFile(path.join(branchDir, 'spec.md'), spec, 'utf8');
+    await writeFile(path.join(branchDir, 'plan.md'), plan, 'utf8');
+    await writeFile(path.join(branchDir, 'tasks.md'), validTaskMarkdown('T1', []), 'utf8');
+    const base = await parseSddBranch(root, 'feature');
+
+    await writeFile(path.join(branchDir, 'spec.md'), `---\nbased_on_spec_hash: ignored\nupdated_at: now\n---\n\n# Spec  \n\n\nInitial requirement.\n\n<!-- runtime note -->\n`, 'utf8');
+    await writeFile(path.join(branchDir, 'plan.md'), `# Plan\n\nbased_on_plan_hash: ignored\n\nInitial plan.\n`, 'utf8');
+    const normalizedOnly = await parseSddBranch(root, 'feature');
+
+    await writeFile(path.join(branchDir, 'spec.md'), '# Spec\n\nChanged requirement.\n', 'utf8');
+    const changed = await parseSddBranch(root, 'feature');
+
+    assert.notEqual(normalizedOnly.documents.specHash, base.documents.specHash);
+    assert.equal(normalizedOnly.documents.specContractHash, base.documents.specContractHash);
+    assert.equal(normalizedOnly.documents.planContractHash, base.documents.planContractHash);
+    assert.notEqual(changed.documents.specContractHash, base.documents.specContractHash);
+    assert.notEqual(hashNormalizedMarkdownContent('# Spec\n\nChanged requirement.\n'), hashNormalizedMarkdownContent(spec));
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
 test('parseSddBranch separates raw doc hash from semantic tasks contract hash', async () => {
   const root = await mkdtemp(path.join(tmpdir(), 'sdd-contract-hash-'));
   try {

package/node_modules/@sdd-agent-platform/core/src/sdd-docs/task-parser.ts

@@ -1,4 +1,4 @@
-import { hashDocumentContent, hashSemanticDocument, hashTasksContract, documentHashMatches } from './document-hashes.js';
+import { hashDocumentContent, hashNormalizedMarkdownContent, hashSemanticDocument, hashTasksContract } from './document-hashes.js';
 import { readdir, readFile } from 'node:fs/promises';
 import path from 'node:path';
 import { assertSafePathSegment } from '../path-safety.js';
@@ -25,6 +25,7 @@ export interface SddValidationCommand {
 
 export interface SddTask {
   id: string;
+  contractHash: string;
   title: string | null;
   status: SddTaskStatus;
   wave: number | null;
@@ -116,17 +117,6 @@ export async function parseSddBranch(projectRoot: string, branch = 'master'): Pr
   const documents = buildDocumentChainState({ specExists, planExists, tasksExists, verifyExists, rawSpec, rawPlan, rawTasks, rawVerify });
   const gaps: SddTaskGap[] = [];
 
-  if (documents.planStale) {
-    gaps.push(documentGap('plan.md', `Plan document is stale because based_on_spec_hash ${documents.planBasedOnSpecHash} no longer matches current spec hash ${documents.specHash}.`, 'Refresh the plan stage for this partition before updating tasks or executing implementation.'));
-  }
-  if (documents.tasksStale) {
-    gaps.push(documentGap('tasks.md', `Tasks document is stale because based_on_plan_hash ${documents.tasksBasedOnPlanHash} no longer matches current plan hash ${documents.planHash}.`, 'Refresh the tasks stage for this partition before executing implementation.'));
-  }
-  if (documents.verifyStale) {
-    const staleBoundary = documents.verifyBasedOnTasksContractHash ? 'tasks contract hash' : 'tasks contract hash binding';
-    const currentHash = documents.verifyBasedOnTasksContractHash ? documents.tasksContractHash : 'required';
-    gaps.push(documentGap('verify.md', `Verify document is stale because based_on_${staleBoundary.replace(/ /g, '_')} ${documents.verifyBasedOnTasksContractHash ?? 'missing'} no longer matches current ${staleBoundary} ${currentHash}.`, 'Run /sdd:tasks or explicit sdd verifies write recovery before /sdd:test.'));
-  }
   if (!specExists) {
     gaps.push(documentGap('spec.md', 'Spec document is missing.', 'Create or restore specs/<branch>/spec.md before full SDD execution.'));
   }
@@ -239,8 +229,10 @@ export function parseSddTasksMarkdown(raw: string, options: { branch?: string; t
     }
     seenIds.set(taskId, source);
 
+    const contractHash = hashTaskContract({ taskId, headingTitle: heading?.title ?? null, metadata, parsedSections });
     const task: SddTask = {
       id: taskId,
+      contractHash,
       title: heading?.title ?? null,
       status: parseTaskStatus(scalarValue(metadata.status)),
       wave: parseWave(scalarValue(metadata.wave)),
@@ -285,31 +277,19 @@ function buildDocumentChainState(input: { specExists: boolean; planExists: boole
   const planDocHash = input.rawPlan === null ? null : hashDocumentContent(input.rawPlan);
   const tasksDocHash = input.rawTasks === null ? null : hashDocumentContent(input.rawTasks);
   const verifyDocHash = input.rawVerify === null ? null : hashDocumentContent(input.rawVerify);
-  const specContractHash = hashSemanticDocument(input.rawSpec);
-  const planContractHash = hashSemanticDocument(input.rawPlan);
+  const specContractHash = hashNormalizedMarkdownContent(input.rawSpec);
+  const planContractHash = hashNormalizedMarkdownContent(input.rawPlan);
   const tasksContractHash = hashTasksContract(input.rawTasks);
   const verifyContractHash = hashSemanticDocument(input.rawVerify);
-  const planBasedOnSpecHash = input.rawPlan === null ? null : readDocumentScalar(input.rawPlan, 'based_on_spec_hash');
-  const tasksBasedOnPlanHash = input.rawTasks === null ? null : readDocumentScalar(input.rawTasks, 'based_on_plan_hash');
-  const verifyBasedOnTasksHash = input.rawVerify === null ? null : readDocumentScalar(input.rawVerify, 'based_on_tasks_hash');
-  const planBasedOnSpecContractHash = input.rawPlan === null ? null : readDocumentScalar(input.rawPlan, 'based_on_spec_contract_hash');
-  const tasksBasedOnPlanContractHash = input.rawTasks === null ? null : readDocumentScalar(input.rawTasks, 'based_on_plan_contract_hash');
-  const verifyBasedOnTasksContractHash = input.rawVerify === null ? null : readDocumentScalar(input.rawVerify, 'based_on_tasks_contract_hash');
-
-  const planStale = Boolean(
-    (planBasedOnSpecContractHash && specContractHash && !documentHashMatches(planBasedOnSpecContractHash, specContractHash))
-    || (!planBasedOnSpecContractHash && planBasedOnSpecHash && specDocHash && !documentHashMatches(planBasedOnSpecHash, specDocHash))
-  );
-  const tasksHashMismatch = Boolean(
-    (tasksBasedOnPlanContractHash && planContractHash && !documentHashMatches(tasksBasedOnPlanContractHash, planContractHash))
-    || (!tasksBasedOnPlanContractHash && tasksBasedOnPlanHash && planDocHash && !documentHashMatches(tasksBasedOnPlanHash, planDocHash))
-  );
-  const verifyHashMismatch = Boolean(
-    input.rawVerify !== null && (
-      !verifyBasedOnTasksContractHash
-      || (verifyBasedOnTasksContractHash && tasksContractHash && !documentHashMatches(verifyBasedOnTasksContractHash, tasksContractHash))
-    )
-  );
+  const planBasedOnSpecHash = null;
+  const tasksBasedOnPlanHash = null;
+  const verifyBasedOnTasksHash = null;
+  const planBasedOnSpecContractHash = null;
+  const tasksBasedOnPlanContractHash = null;
+  const verifyBasedOnTasksContractHash = null;
+  const planStale = false;
+  const tasksHashMismatch = false;
+  const verifyHashMismatch = false;
 
   return {
     specExists: input.specExists,
@@ -340,11 +320,6 @@ function buildDocumentChainState(input: { specExists: boolean; planExists: boole
   };
 }
 
-function readDocumentScalar(raw: string, key: string): string | null {
-  const escapedKey = key.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-  const match = raw.match(new RegExp(`^\\s*(?:-\\s*)?${escapedKey}:\\s*(.+?)\\s*$`, 'm'));
-  return match?.[1]?.trim().replace(/^["'`]|["'`]$/g, '') ?? null;
-}
 
 async function parseRetainedPhaseTasks(specBranchDir: string): Promise<Pick<SddTaskModel, 'tasks' | 'gaps'>> {
   const entries = await readdir(specBranchDir, { withFileTypes: true });
@@ -519,7 +494,7 @@ function lineNumberAt(raw: string, offset: number): number {
 }
 
 function nearestTaskHeading(prefix: string): { raw: string; id: string | null; title: string | null } | null {
-  const matches = Array.from(prefix.matchAll(/^\s*###\s+(.+)$/gm));
+  const matches = Array.from(prefix.matchAll(/^\s*#{2,3}\s+(.+)$/gm));
   const last = matches.at(-1);
   if (!last) {
     return null;
@@ -534,7 +509,7 @@ function nearestTaskHeading(prefix: string): { raw: string; id: string | null; t
 }
 
 function nextTaskStart(raw: string, offset: number, limit = raw.length): number {
-  const next = raw.slice(offset, limit).search(/^\s*###\s+/m);
+  const next = raw.slice(offset, limit).search(/^\s*#{2,3}\s+/m);
   return next < 0 ? limit : offset + next;
 }
 
@@ -546,9 +521,49 @@ function parseTaskCompanionSections(raw: string): { boundary: string | null; acc
   };
 }
 
+function hashTaskContract(input: { taskId: string; headingTitle: string | null; metadata: Record<string, string | string[]>; parsedSections: { boundary: string | null; acceptance: string[]; implementationNotes: string | null } }): string {
+  return hashDocumentContent(JSON.stringify({
+    id: input.taskId,
+    title: input.headingTitle,
+    metadata: {
+      id: normalizedTaskContractValue(input.metadata.id),
+      wave: normalizedTaskContractValue(input.metadata.wave),
+      depends_on: normalizedTaskContractValue(input.metadata.depends_on),
+      acceptance_refs: normalizedTaskContractValue(input.metadata.acceptance_refs),
+      plan_refs: normalizedTaskContractValue(input.metadata.plan_refs),
+      affected_files: normalizedTaskContractValue(input.metadata.affected_files),
+      change_surface: normalizedTaskContractValue(input.metadata.change_surface),
+      implementation_wave: normalizedTaskContractValue(input.metadata.implementation_wave),
+      validation_batch: normalizedTaskContractValue(input.metadata.validation_batch),
+      validation_timing: normalizedTaskContractValue(input.metadata.validation_timing),
+      requires_verify_before_next: normalizedTaskContractValue(input.metadata.requires_verify_before_next),
+      validation: normalizedTaskContractValue(input.metadata.validation),
+      risk: normalizedTaskContractValue(input.metadata.risk),
+      required_artifacts: normalizedTaskContractValue(input.metadata.required_artifacts),
+      allowed_agents: normalizedTaskContractValue(input.metadata.allowed_agents),
+      verification_availability: normalizedTaskContractValue(input.metadata.verification_availability),
+      autonomy: normalizedTaskContractValue(input.metadata.autonomy),
+      validation_wave: normalizedTaskContractValue(input.metadata.validation_wave),
+      review_gate: normalizedTaskContractValue(input.metadata.review_gate)
+    },
+    sections: input.parsedSections
+  }));
+}
+
+function normalizedTaskContractValue(value: string | string[] | undefined): string | string[] | null {
+  if (Array.isArray(value)) {
+    return value.map((item) => item.trim()).filter(Boolean);
+  }
+  if (typeof value === 'string') {
+    const trimmed = value.trim();
+    return trimmed ? trimmed : null;
+  }
+  return null;
+}
+
 function sectionText(raw: string, title: string): string | null {
   const escaped = title.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-  const sectionPattern = `^\\s*####\\s+${escaped}\\s*$([\\s\\S]*?)(?=^\\s*####\\s+|^\\s*###\\s+|$(?![\\s\\S]))`;
+  const sectionPattern = `^\\s*####\\s+${escaped}\\s*$([\\s\\S]*?)(?=^\\s*####\\s+|^\\s*#{2,3}\\s+|$(?![\\s\\S]))`;
   const match = raw.match(new RegExp(sectionPattern, 'im'));
   const text = match?.[1]?.trim() ?? '';
   return text.length > 0 ? text : null;