@aurorajs.dev/catalyst-cli 1.1.3 → 2.0.0

package/dist/templates/monorepo/scripts/backlog/task-view.test.ts

@@ -17,15 +17,16 @@ import {
   DISPATCHER_OWNED_DOD_PATTERNS,
   findUncheckedAcceptanceCriteria,
   findUnownedUncheckedDefinitionOfDone,
+  notesRegion,
   parseBoardTaskIds,
   parseChecklistItems,
-  parseDeclaredBranch,
+  parseDescription,
   parseFilesToTouch,
   parseTaskTitle,
   parseTaskView,
   parseTestCommand,
 } from './task-view.js';
-import { EXECUTION_PATH, LANE, TASK_STATUS, TIER } from './types.js';
+import { EXECUTION_PATH, LANE, MODE, TASK_STATUS, TIER } from './types.js';
 
 // Verbatim `backlog task view TASK-3.1 --plain`: a subtask, with a parent, two dependencies, the
 // four triage labels, and a description carrying both dispatcher conventions.
@@ -149,77 +150,19 @@ describe('parseTaskView — the Test command snapshot', () => {
     assert.equal(parseTestCommand('Scoped test command: pnpm test:hooks\n'), 'pnpm test:hooks');
     assert.equal(parseTestCommand('Just prose.\n'), null);
   });
-});
 
-// T-15: a subtask's base branch is resolved from its PARENT's real branch, not deduced from the
-// parent's id — `guards.ts`'s `taskBaseBranch`/`resolveTaskBase` read this off the PARENT task.
-// This convention is written on the PARENT (the person who created its worktree branch), the same
-// way `Test command:`/`Files to touch:` are written by whoever created the task that declares them.
-describe('parseDeclaredBranch', () => {
-  it('reads the "Branch:" line a person wrote on the parent task', () => {
+  // T-34: `\s*` swallows the newline after an EMPTY `Test command:` value and captures the next
+  // non-blank description line instead — here, `Files to touch:` itself. An empty declared value
+  // must read as "no command declared", the same as no line at all.
+  it('reads an empty Test command value as undeclared, never as the next description line', () => {
     assert.equal(
-      parseDeclaredBranch('Description:\n--------\nBranch: fix/parent-branch-resolution\n'),
-      'fix/parent-branch-resolution',
+      parseTestCommand('Test command:\n\nFiles to touch:\n- scripts/backlog/task-view.ts\n'),
+      null,
     );
   });
 
-  it('is null when the description declares no branch', () => {
-    assert.equal(parseDeclaredBranch('Just prose.\n'), null);
-  });
-
-  it('is case-insensitive on the label, like the other two conventions', () => {
-    assert.equal(parseDeclaredBranch('branch: feat/desktop-shell\n'), 'feat/desktop-shell');
-  });
-
-  it('is bounded to the declaration region, never a forged line in Implementation Notes', () => {
-    const forged = [
-      'Description:',
-      '--------------------------------------------------',
-      'No branch declared here.',
-      '',
-      'Implementation Notes:',
-      '--------------------------------------------------',
-      'Branch: main',
-      '',
-    ].join('\n');
-    assert.equal(parseDeclaredBranch(forged), null);
-  });
-
-  // Fix round B1: `\s` inside `(.+)` matches `\n`, so an empty "Branch:" line used to swallow the
-  // NEXT non-empty line — here, the "Test command:" line itself — and return IT as the declared
-  // branch. The value must be bounded to its own line, the same shape `FILES_TO_TOUCH_LINE` already
-  // uses, and an empty/whitespace-only capture must read as "no declaration", never as a forged
-  // hand-off to whatever text happens to follow.
-  it('does not swallow the next description line when "Branch:" is left empty', () => {
-    const view = [
-      'Description:',
-      '--------------------------------------------------',
-      'Branch:',
-      '',
-      'Test command: pnpm test:backlog',
-      '',
-    ].join('\n');
-    assert.equal(parseDeclaredBranch(view), null);
-  });
-
-  it('is null for a "Branch:" line with only trailing whitespace, never that whitespace', () => {
-    assert.equal(parseDeclaredBranch('Branch:   \nTest command: pnpm test:backlog\n'), null);
-  });
-});
-
-describe('parseTaskView — the declared-branch snapshot', () => {
-  it('carries the declared branch on the Task, beside testCommand', () => {
-    const task = parseTaskView({
-      id: 'T-10',
-      output: 'Description:\n--------\nBranch: fix/parent-branch-resolution\n',
-      attempts: 0,
-    });
-    assert.equal(task.declaredBranch, 'fix/parent-branch-resolution');
-  });
-
-  it('is null when the task declares no branch', () => {
-    const task = parseTaskView({ id: 'T-1', output: QUEUED_VIEW, attempts: 0 });
-    assert.equal(task.declaredBranch, null);
+  it('reads a whitespace-only Test command value as undeclared', () => {
+    assert.equal(parseTestCommand('Test command:   \n\nMore prose.\n'), null);
   });
 });
 
@@ -239,6 +182,16 @@ describe('parseTaskView — triage labels', () => {
     assert.equal(task.path, undefined);
   });
 
+  // T-34 follow-up: `\s*` after the label crosses the newline the same way it did for
+  // `Test command:` — an EMPTY `Labels:` line let the pattern capture the next header line
+  // instead of reading as "no labels". Here that next line looks like a label itself
+  // (`bc:phantom`), so a swallow reads as a real, undeclared `bc:` value instead of `undefined`.
+  it('reads an empty Labels: line as no labels, never as the following header line', () => {
+    const task = parseTaskView({ id: 'T-9', output: 'Labels:\n\nbc:phantom\n', attempts: 0 });
+    assert.equal(task.bc, undefined);
+    assert.equal(task.tier, undefined);
+  });
+
   // J8: the three triage values used to be CAST, never validated, so `lane:Frontier` reached
   // `resolveLane` as a lane nothing matches — the task passed guard 1 as fully triaged and then
   // died in an "unreachable" throw. An unrecognised value must read exactly like a missing one.
@@ -286,6 +239,60 @@ describe('parseTaskView — triage labels', () => {
   });
 });
 
+// ── `mode:` — the fifth mandatory triage label (backlog-dependency-graph / execution mode) ───────
+
+describe('parseTaskView — mode label', () => {
+  it('reads mode:headless off the Labels line, alongside the other triage labels', () => {
+    const task = parseTaskView({
+      id: 'T-9',
+      output: 'Labels: tier:minor, lane:local, path:direct, mode:headless, bc:x\n',
+      attempts: 0,
+    });
+    assert.equal(task.mode, MODE.HEADLESS);
+  });
+
+  it('reads mode:supervised the same way', () => {
+    const task = parseTaskView({
+      id: 'T-9',
+      output: 'Labels: tier:minor, lane:local, path:direct, mode:supervised, bc:x\n',
+      attempts: 0,
+    });
+    assert.equal(task.mode, MODE.SUPERVISED);
+  });
+
+  it('leaves mode undefined when the task carries no mode label at all (guard 1 catches it)', () => {
+    const task = parseTaskView({ id: 'T-9', output: 'Labels: tier:minor, lane:local, path:direct, bc:x\n', attempts: 0 });
+    assert.equal(task.mode, undefined);
+  });
+
+  it('reports an unrecognised mode value as no mode at all, never a cast', () => {
+    const task = parseTaskView({ id: 'T-9', output: 'Labels: mode:Headless\n', attempts: 0 });
+    assert.equal(task.mode, undefined);
+  });
+});
+
+// ── `board:graph` — the graph-holder marker (backlog-dependency-graph capability) ─────────────────
+
+describe('parseTaskView — graph-holder marker', () => {
+  it('reads isGraphHolder true when the task carries the board:graph label', () => {
+    const task = parseTaskView({
+      id: 'T-112',
+      output: 'Labels: tier:minor, lane:local, path:direct, mode:supervised, bc:harness, board:graph\n',
+      attempts: 0,
+    });
+    assert.equal(task.isGraphHolder, true);
+  });
+
+  it('reads isGraphHolder false for an ordinary task', () => {
+    const task = parseTaskView({
+      id: 'T-9',
+      output: 'Labels: tier:minor, lane:local, path:direct, mode:headless, bc:x\n',
+      attempts: 0,
+    });
+    assert.equal(task.isGraphHolder, false);
+  });
+});
+
 describe('parseTaskView — parent and dependencies', () => {
   it('reads the parent id off the Parent line, ignoring the title that follows it', () => {
     assert.equal(
@@ -440,7 +447,7 @@ describe('parseTaskView — parent and dependencies', () => {
     assert.deepEqual(task.dependsOn, ['T-6.1']);
   });
 
-  it('reads every id in a "Depends on" tree that is itself nested (transitive dependencies)', () => {
+  it('excludes a nested branch from dependsOn: indentation marks it transitive, not direct', () => {
     const output = [
       'Task T-9 - A task with a chain of dependencies',
       '==================================================',
@@ -456,14 +463,37 @@ describe('parseTaskView — parent and dependencies', () => {
       '',
       'Description:',
       '--------------------------------------------------',
-      'Depends transitively on the whole chain.',
+      'Depends on T-8 only; T-7 and T-6 are dependencies of T-8, not of this task.',
       '',
     ].join('\n');
-    assert.deepEqual(parseTaskView({ id: 'T-9', output, attempts: 0 }).dependsOn, [
-      'T-8',
-      'T-7',
-      'T-6',
-    ]);
+    assert.deepEqual(parseTaskView({ id: 'T-9', output, attempts: 0 }).dependsOn, ['T-8']);
+  });
+
+  // A branch's descendants are indented with plain spaces whenever it is the LAST branch at its
+  // level (see the module doc comment above `DEPENDENCY_BRANCH`) — including the last of several
+  // SIBLINGS, not only a lone branch. This keeps that shape apart from an EARLIER sibling's own
+  // nested branch, which the tree indents with the vertical-continuation glyph `│` instead.
+  it('reads only the unindented branches as direct, even when the last one shares a transitive dependency with an earlier one', () => {
+    const output = [
+      'Task T-1 - A task with two direct dependencies sharing one transitive dependency',
+      '==================================================',
+      '',
+      'Status: ○ To Do',
+      '',
+      'Dependency Graph:',
+      '--------------------------------------------------',
+      'Depends on (2 direct, 3 total):',
+      '├─ T-2 - First direct dependency [To Do]',
+      '│  └─ T-4 - Shared transitive dependency [To Do]',
+      '└─ T-3 - Last direct dependency [To Do]',
+      '   └─ T-4 - Shared transitive dependency [To Do]',
+      '',
+      'Description:',
+      '--------------------------------------------------',
+      'Depends on T-2 and T-3 only.',
+      '',
+    ].join('\n');
+    assert.deepEqual(parseTaskView({ id: 'T-1', output, attempts: 0 }).dependsOn, ['T-2', 'T-3']);
   });
 });
 
@@ -713,6 +743,131 @@ describe('the header region bounds the header fields', () => {
   });
 });
 
+// ── T-68: the notes section's own body, bounded on both sides ─────────────────────────────────
+
+describe('notesRegion', () => {
+  it('reads only the Implementation Notes: body, not the description above it', () => {
+    const output = [
+      'Task T-9 - A task',
+      '==================================================',
+      '',
+      'Status: ◒ In Progress',
+      '',
+      'Description:',
+      '--------------------------------------------------',
+      '## Registro de ejecución lives here in the DESCRIPTION, never the notes.',
+      '',
+      'Implementation Notes:',
+      '--------------------------------------------------',
+      'Progress note one.',
+      'Progress note two.',
+    ].join('\n');
+    const notes = notesRegion(output);
+    assert.equal(notes, 'Progress note one.\nProgress note two.');
+    assert.ok(!notes.includes('lives here in the DESCRIPTION'));
+  });
+
+  it('stops at the NEXT rendered section (Comments:), never bleeding into it', () => {
+    const output = [
+      'Task T-9 - A task',
+      '==================================================',
+      '',
+      'Status: ◒ In Progress',
+      '',
+      'Description:',
+      '--------------------------------------------------',
+      'Nothing forged here.',
+      '',
+      'Implementation Notes:',
+      '--------------------------------------------------',
+      'The real note.',
+      '',
+      'Comments:',
+      '--------------------------------------------------',
+      '#1 - 2026-09-07 10:00 (UTC)',
+      'A comment, not a note.',
+    ].join('\n');
+    const notes = notesRegion(output);
+    assert.equal(notes, 'The real note.');
+    assert.ok(!notes.includes('A comment, not a note.'));
+  });
+
+  it('returns "" for a task with no notes section at all', () => {
+    const output = [
+      'Task T-9 - A task',
+      '==================================================',
+      '',
+      'Status: ◒ In Progress',
+      '',
+      'Description:',
+      '--------------------------------------------------',
+      'Nothing here.',
+    ].join('\n');
+    assert.equal(notesRegion(output), '');
+  });
+
+  it('reads the bare "Notes:" heading a task with no prior notes renders', () => {
+    const output = [
+      'Task T-9 - A task',
+      '==================================================',
+      '',
+      'Status: ◒ In Progress',
+      '',
+      'Notes:',
+      '--------------------------------------------------',
+      'The first note ever written.',
+    ].join('\n');
+    assert.equal(notesRegion(output), 'The first note ever written.');
+  });
+});
+
+describe('parseDescription', () => {
+  it('reads the Description: body, stopping at the next rendered section', () => {
+    const output = [
+      'Task T-112 - Graph holder',
+      '==================================================',
+      '',
+      'Status: ○ To Do',
+      '',
+      'Description:',
+      '--------------------------------------------------',
+      'Line one of the rendered view.',
+      'Line two of the rendered view.',
+      '',
+      'Acceptance Criteria:',
+      '--------------------------------------------------',
+      '- [ ] #1 Not part of the description.',
+    ].join('\n');
+    assert.equal(
+      parseDescription(output),
+      'Line one of the rendered view.\nLine two of the rendered view.',
+    );
+  });
+
+  it('returns "" for a task with no Description: heading at all', () => {
+    assert.equal(parseDescription('Task T-9 - A task\n\nStatus: To Do\n'), '');
+  });
+
+  it('never reads past a worker-writable section forged inside the description text', () => {
+    // A description that merely CONTAINS the words "Implementation Notes:" with no dashed
+    // underline is content, not a boundary — the same rule `declarationRegion` enforces.
+    const output = [
+      'Task T-9 - A task',
+      '==================================================',
+      '',
+      'Status: ○ To Do',
+      '',
+      'Description:',
+      '--------------------------------------------------',
+      'Mentions Implementation Notes: in passing, with no underline.',
+    ].join('\n');
+    assert.equal(
+      parseDescription(output),
+      'Mentions Implementation Notes: in passing, with no underline.',
+    );
+  });
+});
+
 // ── M4: a worker-writable section is a HEADING, and a heading carries its underline ───────────
 
 describe('the declaration region boundary requires the dashed underline', () => {

package/dist/templates/monorepo/scripts/backlog/task-view.ts

@@ -14,7 +14,9 @@
 import {
   BOARD_STATUSES,
   EXECUTION_PATH,
+  GRAPH_HOLDER_LABEL,
   LANE,
+  MODE,
   TASK_STATUS,
   TIER,
   type Task,
@@ -71,15 +73,90 @@ function declarationRegion(taskText: string): string {
   return boundary ? taskText.slice(0, boundary.index) : taskText;
 }
 
+/**
+ * The `Implementation Notes:`/`Notes:` heading specifically — `WORKER_WRITABLE_SECTION` above also
+ * matches `Implementation Plan:` and `Comments:`, which are NOT the notes body and must never be
+ * read as one.
+ */
+const NOTES_HEADING = /^(?:Implementation Notes|Notes):[^\S\n]*\n-+[^\S\n]*$/m;
+
+/**
+ * The notes section's OWN body — T-68's reader, for a caller that must tell "the heading is in the
+ * notes" apart from "the heading is in the description, the AC, or a comment". Bounded by the NEXT
+ * rendered section heading (`SECTION_HEADING`, typically `Comments:`), so a heading-shaped line
+ * INSIDE the notes' own text (a worker's report can legitimately contain almost anything) is read as
+ * CONTENT, never as the boundary — the same principle `declarationRegion`'s own JSDoc explains for
+ * why a boundary needs the dashed underline, not just the label.
+ *
+ * `''` when the task carries no notes section at all — a task that has never received `--notes`/
+ * `--append-notes` renders neither heading.
+ */
+export function notesRegion(taskText: string): string {
+  const heading = NOTES_HEADING.exec(taskText);
+  if (!heading) {
+    return '';
+  }
+  const afterHeading = taskText.slice(heading.index + heading[0].length);
+  const nextSection = SECTION_HEADING.exec(afterHeading);
+  const body = nextSection ? afterHeading.slice(0, nextSection.index) : afterHeading;
+  return body.trim();
+}
+
+const DESCRIPTION_HEADING = /^Description:[^\S\n]*\n-+[^\S\n]*$/m;
+
+/**
+ * The `Description:` section's own body — `graph.ts`'s `--write` uses this to compare the
+ * graph-holder task's CURRENT description against the freshly rendered one, so it writes only on a
+ * difference. Bounded by the next rendered section, exactly like `notesRegion` above, for the same
+ * reason: a heading-shaped line inside the description's own prose (a task can legitimately discuss
+ * anything) is content, never a boundary, unless it carries the dashed underline.
+ *
+ * `''` when the task carries no `Description:` heading at all — the empty-description case.
+ */
+export function parseDescription(fullText: string): string {
+  const taskText = declarationRegion(fullText);
+  const heading = DESCRIPTION_HEADING.exec(taskText);
+  if (!heading) {
+    return '';
+  }
+  const afterHeading = taskText.slice(heading.index + heading[0].length);
+  const nextSection = SECTION_HEADING.exec(afterHeading);
+  const body = nextSection ? afterHeading.slice(0, nextSection.index) : afterHeading;
+  return body.trim();
+}
+
+// ── Header value lines ──────────────────────────────────────────────────────────
+
+/**
+ * A `Label: <value>` line, with the value bounded to its OWN LINE — never `\s*`, which also
+ * matches a newline: an EMPTY value (`Label:` with nothing after it) let `\s*` cross into the
+ * following header line and capture THAT as the value instead of reading as "no value declared"
+ * (T-34, first found on `Test command:`, then measured to hit every sibling below the same way —
+ * an empty `Labels:` swallowing the next header line is a real untriaged-subtask shape, since
+ * Backlog.md renders `Labels:` directly above `Parent:` with no blank line between them).
+ *
+ * `label` is itself regex-composable text, not always a literal word — `TEST_COMMAND_LINE` passes
+ * an alternation (`(?:Scoped )?test command`) the same way `PARENT_LINE` passes `TASK_ID.source`
+ * elsewhere in this file. Extra `flags` past the default `'m'` are for case-insensitive labels
+ * inside the description body (`FILES_TO_TOUCH_LINE`, `TEST_COMMAND_LINE`), never for the header
+ * fields, which the CLI always renders with a fixed case.
+ */
+function headerValueLine(label: string, flags = 'm'): RegExp {
+  return new RegExp(String.raw`^${label}:[^\S\n]*(.*)$`, flags);
+}
+
 // ── Line-level readers (header region) ────────────────────────────────────────
 
+const STATUS_LINE = headerValueLine('Status');
+
 /**
  * Backlog.md renders the status with a leading state glyph (`○ To Do`, `◒ In Progress`,
- * `● Blocked`) that is absent in some builds and configs. Skipping "the first whitespace-delimited
- * token" reads `Status: To Do` as `Do`, so the optional prefix is matched as NON-LETTERS only —
- * a glyph can never be confused with the first word of the status itself.
+ * `● Blocked`) that is absent in some builds and configs. Stripped from the CAPTURED value
+ * (rather than folded into `STATUS_LINE` itself) so the line-isolation shape stays identical
+ * across every header reader — a glyph can never be confused with the first word of the status
+ * itself, since the strip requires at least one NON-letter, non-space character before it.
  */
-const STATUS_LINE = /^Status:\s*(?:[^\sA-Za-z]+\s+)?(.+?)\s*$/m;
+const STATUS_GLYPH_PREFIX = /^[^\sA-Za-z]+\s+/;
 
 /**
  * The status line, validated against the real board columns — never cast blindly: an unreadable
@@ -88,29 +165,35 @@ const STATUS_LINE = /^Status:\s*(?:[^\sA-Za-z]+\s+)?(.+?)\s*$/m;
  */
 export function parseTaskStatus(taskText: string): TaskStatus {
   const raw = STATUS_LINE.exec(headerRegion(taskText))?.[1];
-  return BOARD_STATUSES.find((status) => status === raw) ?? TASK_STATUS.UNKNOWN;
+  const status = raw?.trim().replace(STATUS_GLYPH_PREFIX, '');
+  return BOARD_STATUSES.find((candidate) => candidate === status) ?? TASK_STATUS.UNKNOWN;
 }
 
-const PRIORITY_LINE = /^Priority:\s*(\w+)$/m;
-const LABELS_LINE = /^Labels:\s*(.+)$/m;
-const CREATED_LINE = /^Created:\s*(.+?)(\s*\(UTC\))?$/m;
+const PRIORITY_LINE = headerValueLine('Priority');
+const LABELS_LINE = headerValueLine('Labels');
+const CREATED_LINE = headerValueLine('Created');
 /**
- * `Updated:` mirrors `Created:` exactly — same "space-separated, UTC-marked" rendering, same
- * `(.+?)(\s*\(UTC\))?` shape — because it is the SAME timestamp mechanism the CLI already renders
- * for creation, just re-stamped on every edit. Kept as its own regex (rather than reusing
- * `CREATED_LINE` with a different label) so a future change to one heading's rendering does not
- * silently reach the other.
+ * `Updated:` mirrors `Created:` exactly — same rendering, same shape — because it is the SAME
+ * timestamp mechanism the CLI already renders for creation, just re-stamped on every edit. Kept as
+ * its own regex (rather than reusing `CREATED_LINE` with a different label) so a future change to
+ * one heading's rendering does not silently reach the other.
  */
-const UPDATED_LINE = /^Updated:\s*(.+?)(\s*\(UTC\))?$/m;
+const UPDATED_LINE = headerValueLine('Updated');
+
+/** The `(UTC)` marker `Created:`/`Updated:` append, on the SAME line as the timestamp. */
+const UTC_MARKER = /\s*\(UTC\)$/;
 
 /**
  * `Created: 2026-09-06 15:40 (UTC)` is UTC, but `Date.parse` reads the space-separated form as
  * LOCAL time — a silent hours-wide skew in the age tiebreaker. Rewritten to an ISO instant so the
  * `(UTC)` marker the CLI prints is actually honored. Shared by `Created:` and `Updated:` — both
- * render the same way, so both parse the same way.
+ * render the same way, so both parse the same way. Takes the WHOLE captured line value and strips
+ * the marker itself (rather than a second capture group in the line regex, the pre-T-34 shape) so
+ * `headerValueLine` stays one single-purpose builder for every header reader.
  */
-function parseCreatedAt(raw: string, hadUtcMarker: boolean): number {
-  const isoish = raw.trim().replace(' ', 'T');
+function parseCreatedAt(rawValue: string): number {
+  const hadUtcMarker = UTC_MARKER.test(rawValue);
+  const isoish = rawValue.replace(UTC_MARKER, '').trim().replace(' ', 'T');
   const withSeconds = /T\d{2}:\d{2}$/.test(isoish) ? `${isoish}:00` : isoish;
   return Date.parse(hadUtcMarker ? `${withSeconds}Z` : withSeconds) || 0;
 }
@@ -151,6 +234,16 @@ export function parseTaskTitle(taskText: string): string | null {
  * task ids ("Fix T-7 regression"), and treating those as dependencies would deadlock the task
  * behind an id it never declared.
  *
+ * A direct dependency is an UNINDENTED branch, flush with the left margin under the "Depends on
+ * (N direct, M total):" heading. Anything indented under it is TRANSITIVE — a dependency of that
+ * dependency, rendered for context, never a dependency of this task. The CLI marks whether a
+ * sibling follows at a level by how it indents that branch's OWN descendants, not by the branch's
+ * prefix: a branch with a sibling still below keeps a vertical line open for it (`│  └─ …`), while
+ * the LAST branch at a level has no sibling to keep it open for, so its descendants are indented
+ * with plain spaces (`   └─ …`) — indistinguishable, without counting columns, from a fresh
+ * top-level branch. Indentation is therefore the only reliable signal: zero means direct, any
+ * amount means transitive.
+ *
  * The graph carries up to TWO subsections — "Depends on (…):" (what this task waits on) and
  * "Dependents (…):" (what waits on THIS task) — in that order, separated by a blank line, either
  * one optional on its own. Only the first one counts as a dependency: a task with no "Depends on"
@@ -161,10 +254,8 @@ export function parseTaskTitle(taskText: string): string | null {
  */
 const DEPENDENCY_SECTION = /^Dependency Graph:\s*\n-+\s*\n/m;
 const DEPENDS_ON_HEADING = /^Depends on \(\d+ direct, \d+ total\):/;
-const DEPENDENCY_BRANCH = new RegExp(
-  String.raw`^[^\S\n]*[├└][^\S\n]*─[^\S\n]*(${TASK_ID.source})\b`,
-  'gm',
-);
+/** Anchored at column 0 on purpose: an indented `├─`/`└─` is a transitive branch, never a direct one. */
+const DEPENDENCY_BRANCH = new RegExp(String.raw`^[├└][^\S\n]*─[^\S\n]*(${TASK_ID.source})\b`, 'gm');
 
 function parseDependencies(fullText: string): string[] {
   const taskText = declarationRegion(fullText);
@@ -186,7 +277,7 @@ function parseDependencies(fullText: string): string[] {
 
 // ── "Files to touch" convention ────────────────────────────────────────────────
 
-const FILES_TO_TOUCH_LINE = /^files to touch:[^\S\n]*(.*)$/im;
+const FILES_TO_TOUCH_LINE = headerValueLine('files to touch', 'im');
 const LIST_ITEM = /^[^\S\n]*[-*][^\S\n]+(.+?)[^\S\n]*$/;
 
 /**
@@ -227,45 +318,20 @@ export function parseFilesToTouch(fullText: string): string[] {
 
 // ── "Test command" convention ─────────────────────────────────────────────────
 
-const TEST_COMMAND_LINE = /^(?:Scoped )?test command:\s*(.+)$/im;
-
 /**
- * Reads the `catalyst-backlog` skill's "Test command: <cmd>" description line — the command the
- * close's mechanical triad runs — or `null` when the description declares none. Lives here beside
- * `parseFilesToTouch` because both are conventions inside the same `--plain` text, and this module
- * owns that format.
+ * Reuses `headerValueLine` (this is the shape T-34 first fixed it for — see that builder's own
+ * JSDoc). The label itself is an alternation, not a literal word: a `Scoped ` prefix is optional.
  */
-export function parseTestCommand(fullText: string): string | null {
-  const match = TEST_COMMAND_LINE.exec(declarationRegion(fullText));
-  return match ? match[1].trim() : null;
-}
-
-// ── "Branch" convention ────────────────────────────────────────────────────────
+const TEST_COMMAND_LINE = headerValueLine('(?:Scoped )?test command', 'im');
 
 /**
- * `[^\S\n]*` — not `\s*` — between the label and the value, the same shape `FILES_TO_TOUCH_LINE`
- * uses: `\s` matches `\n`, so `\s*(.+)` on an EMPTY "Branch:" line would skip the blank line
- * entirely and let `(.+)` capture the next non-blank line instead — a fix-round defect (B1)
- * measured end to end: an empty "Branch:" line followed by "Test command: …" returned the test
- * command's text AS the declared branch.
- */
-const BRANCH_LINE = /^branch:[^\S\n]*(.*)$/im;
-
-/**
- * Reads the `catalyst-backlog` skill's "Branch: <name>" description convention — the FIRST link of
- * `guards.ts`'s base-branch resolution chain (`taskBaseBranch`/`resolveTaskBase`): a person writes
- * this on a PARENT task right after creating its worktree branch, since an interactive session's
- * branch is almost never `task/<id>` (the root `CLAUDE.md`'s Worktree Gate names it by
- * conventional-commit scope instead). `null` when the description declares none, when the line is
- * present but its value is empty or whitespace-only (an empty declaration is not a declaration),
- * or for a declaration that ONLY a worker's own writable sections carry (see `declarationRegion`)
- * — a subtask cannot forge its own parent's branch through its notes, since the parent is a
- * DIFFERENT task the subtask holds no edit grant on, but the same region bound applies here for the
- * same reason it applies to `parseTestCommand`.
+ * Reads the `catalyst-backlog` skill's "Test command: <cmd>" description line — the command the
+ * close's mechanical triad runs — or `null` when the description declares none, INCLUDING a line
+ * present but left blank: an empty declaration is "no command declared", never a license to read
+ * whatever text happens to follow it.
  */
-export function parseDeclaredBranch(fullText: string): string | null {
-  const match = BRANCH_LINE.exec(declarationRegion(fullText));
-  const value = match?.[1].trim();
+export function parseTestCommand(fullText: string): string | null {
+  const value = TEST_COMMAND_LINE.exec(declarationRegion(fullText))?.[1].trim();
   return value ? value : null;
 }
 
@@ -407,7 +473,7 @@ export function parseTaskView(input: ParseTaskViewInput): Task {
 
   const createdMatch = CREATED_LINE.exec(header);
   const updatedMatch = UPDATED_LINE.exec(header);
-  const createdAt = createdMatch ? parseCreatedAt(createdMatch[1], Boolean(createdMatch[2])) : 0;
+  const createdAt = createdMatch ? parseCreatedAt(createdMatch[1]) : 0;
 
   return {
     id: input.id,
@@ -416,11 +482,14 @@ export function parseTaskView(input: ParseTaskViewInput): Task {
     tier: triageValue('tier:', TIER),
     lane: triageValue('lane:', LANE),
     path: triageValue('path:', EXECUTION_PATH),
+    mode: triageValue('mode:', MODE),
     // `bc:` stays free text on purpose: it names a bounded context, which is an open set.
     bc: labelValue('bc:'),
+    // The graph-holder marker (`backlog-dependency-graph` capability) is a bare label, not a
+    // `prefix:value` pair — presence on the Labels line is the whole signal.
+    isGraphHolder: labels.includes(GRAPH_HOLDER_LABEL),
     filesToTouch: parseFilesToTouch(output),
     testCommand: parseTestCommand(output),
-    declaredBranch: parseDeclaredBranch(output),
     acceptanceCriteria: parseChecklistItems(output, ACCEPTANCE_CRITERIA_HEADING).map(
       (item) => item.text,
     ),
@@ -439,6 +508,6 @@ export function parseTaskView(input: ParseTaskViewInput): Task {
     // fresh, correctly-triaged task on its very first pass. `createdAt` is the honest fallback: a
     // task with no more recent edit has no timestamp more recent than its own creation to report —
     // never a timestamp older than time itself.
-    updatedAt: updatedMatch ? parseCreatedAt(updatedMatch[1], Boolean(updatedMatch[2])) : createdAt,
+    updatedAt: updatedMatch ? parseCreatedAt(updatedMatch[1]) : createdAt,
   };
 }