@rasensio/aidlc 1.20.0 → 1.22.0

package/dist/roadmap/sync/labels.js

@@ -0,0 +1,80 @@
+/**
+ * The label vocabulary the projection uses.
+ *
+ * Two kinds of label, doing two different jobs:
+ *
+ * - **The discovery label** (`aidlc` by default) is how the whole issue map is found in
+ *   one `gh issue list` call. It is identity: an issue without it is invisible to the
+ *   projection.
+ * - **A status label** (`aidlc:backlog`, `aidlc:done`, …) is how a reader tells planned
+ *   from in-flight without opening anything.
+ *
+ * The status names are *derived* from `ROADMAP_STATUSES` rather than listed here, so the
+ * two vocabularies cannot drift: adding a sixth status becomes a compile-time fact
+ * instead of a label nobody remembered to add.
+ *
+ * `LABEL_COLOR` and `LABEL_DESCRIPTION` exist because `gh label create` exits 1 on a
+ * label that already exists, so creation must pass `--force` — and `gh` chooses a
+ * *random* colour when none is given, so `--force` without an explicit colour would
+ * repaint the label on every single run. Fixed values make the ensure genuinely
+ * idempotent.
+ *
+ * Requirements: roadmap-issue-projection/AC-17, roadmap-issue-projection/AC-43
+ *
+ * @module
+ */
+import { ROADMAP_STATUSES } from '../paths.js';
+/** Default discovery label. Overridable via `roadmap.sync.label`. */
+export const DEFAULT_DISCOVERY_LABEL = 'aidlc';
+/** GitHub's own label-name limit. */
+export const MAX_LABEL_LENGTH = 50;
+/** Prefix marking a label this projection owns. */
+export const STATUS_LABEL_PREFIX = 'aidlc:';
+/** The label carrying an item's status. */
+export function statusLabel(status) {
+    return `${STATUS_LABEL_PREFIX}${status}`;
+}
+/** Every status label, derived. */
+export const ALL_STATUS_LABELS = ROADMAP_STATUSES.map(statusLabel);
+/**
+ * True when a label name is one this projection owns.
+ *
+ * Used to decide what `update-labels` may remove. Anything failing this test is a
+ * human's label and is never touched — which is why the update uses `--add-label` /
+ * `--remove-label` rather than a wholesale `--label` replacement.
+ */
+export function isStatusLabel(name) {
+    return ALL_STATUS_LABELS.includes(name);
+}
+/** Fixed colours, so `--force` is idempotent rather than a repaint. */
+export const LABEL_COLOR = {
+    [DEFAULT_DISCOVERY_LABEL]: '5319e7',
+    [statusLabel('inbox')]: 'bfd4f2',
+    [statusLabel('backlog')]: '1d76db',
+    [statusLabel('in-progress')]: '0e8a16',
+    [statusLabel('done')]: '6f42c1',
+    [statusLabel('hold')]: 'd4c5f9',
+};
+/** Fallback colour for a custom discovery label. */
+export const FALLBACK_LABEL_COLOR = '5319e7';
+/** Fixed descriptions, for the same reason as the colours. */
+export const LABEL_DESCRIPTION = {
+    [statusLabel('inbox')]: 'AIDLC roadmap: captured, not yet triaged',
+    [statusLabel('backlog')]: 'AIDLC roadmap: agreed, not started',
+    [statusLabel('in-progress')]: 'AIDLC roadmap: a lifecycle instance exists',
+    [statusLabel('done')]: 'AIDLC roadmap: shipped',
+    [statusLabel('hold')]: 'AIDLC roadmap: parked or declined',
+};
+/** Fallback description for the discovery label, whatever it is named. */
+export function discoveryLabelDescription() {
+    return 'Projected from this repository’s AIDLC roadmap';
+}
+/** Colour for a label name, falling back for a custom discovery label. */
+export function colorFor(name) {
+    return LABEL_COLOR[name] ?? FALLBACK_LABEL_COLOR;
+}
+/** Description for a label name, falling back for a custom discovery label. */
+export function descriptionFor(name) {
+    return LABEL_DESCRIPTION[name] ?? discoveryLabelDescription();
+}
+//# sourceMappingURL=labels.js.map

package/dist/roadmap/sync/labels.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"labels.js","sourceRoot":"","sources":["../../../src/roadmap/sync/labels.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,EAAE,gBAAgB,EAAsB,MAAM,aAAa,CAAC;AAEnE,qEAAqE;AACrE,MAAM,CAAC,MAAM,uBAAuB,GAAG,OAAO,CAAC;AAE/C,qCAAqC;AACrC,MAAM,CAAC,MAAM,gBAAgB,GAAG,EAAE,CAAC;AAEnC,mDAAmD;AACnD,MAAM,CAAC,MAAM,mBAAmB,GAAG,QAAQ,CAAC;AAE5C,2CAA2C;AAC3C,MAAM,UAAU,WAAW,CAAC,MAAqB;IAC/C,OAAO,GAAG,mBAAmB,GAAG,MAAM,EAAE,CAAC;AAC3C,CAAC;AAED,mCAAmC;AACnC,MAAM,CAAC,MAAM,iBAAiB,GAAsB,gBAAgB,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;AAEtF;;;;;;GAMG;AACH,MAAM,UAAU,aAAa,CAAC,IAAY;IACxC,OAAQ,iBAAuC,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;AACjE,CAAC;AAED,uEAAuE;AACvE,MAAM,CAAC,MAAM,WAAW,GAAqC;IAC3D,CAAC,uBAAuB,CAAC,EAAE,QAAQ;IACnC,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC,EAAE,QAAQ;IAChC,CAAC,WAAW,CAAC,SAAS,CAAC,CAAC,EAAE,QAAQ;IAClC,CAAC,WAAW,CAAC,aAAa,CAAC,CAAC,EAAE,QAAQ;IACtC,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,EAAE,QAAQ;IAC/B,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,EAAE,QAAQ;CAChC,CAAC;AAEF,oDAAoD;AACpD,MAAM,CAAC,MAAM,oBAAoB,GAAG,QAAQ,CAAC;AAE7C,8DAA8D;AAC9D,MAAM,CAAC,MAAM,iBAAiB,GAAqC;IACjE,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC,EAAE,0CAA0C;IAClE,CAAC,WAAW,CAAC,SAAS,CAAC,CAAC,EAAE,oCAAoC;IAC9D,CAAC,WAAW,CAAC,aAAa,CAAC,CAAC,EAAE,4CAA4C;IAC1E,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,EAAE,wBAAwB;IAC/C,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,EAAE,mCAAmC;CAC3D,CAAC;AAEF,0EAA0E;AAC1E,MAAM,UAAU,yBAAyB;IACvC,OAAO,gDAAgD,CAAC;AAC1D,CAAC;AAED,0EAA0E;AAC1E,MAAM,UAAU,QAAQ,CAAC,IAAY;IACnC,OAAO,WAAW,CAAC,IAAI,CAAC,IAAI,oBAAoB,CAAC;AACnD,CAAC;AAED,+EAA+E;AAC/E,MAAM,UAAU,cAAc,CAAC,IAAY;IACzC,OAAO,iBAAiB,CAAC,IAAI,CAAC,IAAI,yBAAyB,EAAE,CAAC;AAChE,CAAC"}

package/dist/roadmap/sync/markdown.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Where markdown is code and where it is prose.
+ *
+ * One primitive, three consumers — the sanitizer, the item-reference linker, and the
+ * marker scanner. They have to agree: if the sanitizer defuses something the marker
+ * scanner still sees as a comment, the projection refuses runs for a hazard that is no
+ * longer there; if they disagree the other way, a quoted marker injects itself into an
+ * issue. Agreement is cheap to state as a shared function and expensive to maintain as a
+ * convention across three regexes.
+ *
+ * Measured on this project's roadmap (76 items, 451,503 characters of body text) on
+ * 2026-09-07: 40 of the 41 hazard spans a naive sanitizer would rewrite are **inside
+ * code** — `@clack/prompts`, `actions/checkout@v4`, CSS colour hexes such as `#0891b2`
+ * that a `#123` pattern also matches, and one HTML comment. Exactly one is in prose. So
+ * code-awareness is not a refinement of the sanitizer; it is the difference between
+ * corrupting 40 spans and defusing 1.
+ *
+ * The inline-code pattern here is deliberately stronger than the prior art in
+ * `packages/website/scripts/blog/mdx-escape.mjs`, whose `` /(`[^`\n]*`)/ `` recognises
+ * single-backtick spans only. Two of the figures above were wrong under that weaker
+ * pattern: it read a prose `#17` as code, and it could not see that all 32 item-id
+ * references are code spans. Tightening the pattern is the reason this module exists
+ * rather than a detail of it — which is also why `mdx-escape.mjs` is left alone: it
+ * escapes for a different dialect, in a different package, and widening it would be a
+ * change to the blog pipeline nobody asked for.
+ *
+ * Requirements: richer-issue-bodies/AC-8
+ *
+ * @module
+ */
+/** One inline code span, with its bounds in the source and its content between the ticks. */
+export interface CodeSpan {
+    /** Index of the first backtick. */
+    start: number;
+    /** Index one past the last backtick. */
+    end: number;
+    /** Text between the backtick runs, unmodified. */
+    content: string;
+    /** How many backticks delimit it, so a rewrite can re-wrap with the same number. */
+    ticks: number;
+}
+/**
+ * A byte per character: 1 inside a fenced block or an inline code span, 0 in prose.
+ *
+ * Fence opener and closer lines are themselves marked as code. That is deliberate: an
+ * info string such as ```` ```ts ```` is not prose, and a rule that rewrote it would
+ * change what language a block claims to be.
+ *
+ * Linear in the length of the text: one pass over lines, and one regex walk per prose
+ * line.
+ */
+export declare function codeMask(text: string): Uint8Array;
+/**
+ * Every inline code span outside a fenced block, in order of appearance.
+ *
+ * Spans *inside* a fence are not returned: their backticks are literal text there, and a
+ * caller rewriting one would be editing the contents of a code block.
+ */
+export declare function inlineCodeSpans(text: string): CodeSpan[];
+/**
+ * Rewrite the prose runs of a document, copying every code run byte-identical.
+ *
+ * `fn` is called once per maximal prose run. It may return text of any length — offsets
+ * are not preserved across the call, which is why the mask is computed once up front
+ * rather than consulted per match.
+ */
+export declare function mapProse(text: string, fn: (prose: string) => string): string;
+/**
+ * The last index at or before `limit` where a line break sits in **prose**.
+ *
+ * Used to choose a truncation point. A blank line inside a fenced block is masked as
+ * code, so restricting the cut to an unmasked newline is what stops truncation leaving a
+ * fence open — a body ending mid-fence renders the rest of the issue as one code block.
+ *
+ * Returns -1 when no such position exists, which the caller must treat as "cannot
+ * truncate safely" rather than as position 0.
+ */
+export declare function lastProseBreakBefore(text: string, limit: number): number;
+//# sourceMappingURL=markdown.d.ts.map

package/dist/roadmap/sync/markdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdown.d.ts","sourceRoot":"","sources":["../../../src/roadmap/sync/markdown.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAkBH,6FAA6F;AAC7F,MAAM,WAAW,QAAQ;IACvB,mCAAmC;IACnC,KAAK,EAAE,MAAM,CAAC;IACd,wCAAwC;IACxC,GAAG,EAAE,MAAM,CAAC;IACZ,kDAAkD;IAClD,OAAO,EAAE,MAAM,CAAC;IAChB,oFAAoF;IACpF,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;;;GASG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,CAkCjD;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,EAAE,CA2BxD;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,GAAG,MAAM,CAc5E;AAED;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAMxE"}

package/dist/roadmap/sync/markdown.js

@@ -0,0 +1,165 @@
+/**
+ * Where markdown is code and where it is prose.
+ *
+ * One primitive, three consumers — the sanitizer, the item-reference linker, and the
+ * marker scanner. They have to agree: if the sanitizer defuses something the marker
+ * scanner still sees as a comment, the projection refuses runs for a hazard that is no
+ * longer there; if they disagree the other way, a quoted marker injects itself into an
+ * issue. Agreement is cheap to state as a shared function and expensive to maintain as a
+ * convention across three regexes.
+ *
+ * Measured on this project's roadmap (76 items, 451,503 characters of body text) on
+ * 2026-09-07: 40 of the 41 hazard spans a naive sanitizer would rewrite are **inside
+ * code** — `@clack/prompts`, `actions/checkout@v4`, CSS colour hexes such as `#0891b2`
+ * that a `#123` pattern also matches, and one HTML comment. Exactly one is in prose. So
+ * code-awareness is not a refinement of the sanitizer; it is the difference between
+ * corrupting 40 spans and defusing 1.
+ *
+ * The inline-code pattern here is deliberately stronger than the prior art in
+ * `packages/website/scripts/blog/mdx-escape.mjs`, whose `` /(`[^`\n]*`)/ `` recognises
+ * single-backtick spans only. Two of the figures above were wrong under that weaker
+ * pattern: it read a prose `#17` as code, and it could not see that all 32 item-id
+ * references are code spans. Tightening the pattern is the reason this module exists
+ * rather than a detail of it — which is also why `mdx-escape.mjs` is left alone: it
+ * escapes for a different dialect, in a different package, and widening it would be a
+ * change to the blog pipeline nobody asked for.
+ *
+ * Requirements: richer-issue-bodies/AC-8
+ *
+ * @module
+ */
+/**
+ * A fence opener or closer: up to three leading spaces, then three or more backticks or
+ * tildes. CommonMark's rule, and the same one `mdx-escape.mjs` applies.
+ */
+const FENCE_RE = /^\s{0,3}(`{3,}|~{3,})/;
+/**
+ * One inline code span.
+ *
+ * A run of N backticks closed by a run of **exactly** N — not by a prefix of a longer
+ * run, which is what the lookarounds buy. Without them `` ``a`` `` reads as a one-backtick
+ * span containing `` `a `` and the classification of everything after it on the line
+ * shifts by one span.
+ */
+const INLINE_CODE_RE = /(?<!`)(`+)(?!`)([^\n]*?)(?<!`)\1(?!`)/g;
+/**
+ * A byte per character: 1 inside a fenced block or an inline code span, 0 in prose.
+ *
+ * Fence opener and closer lines are themselves marked as code. That is deliberate: an
+ * info string such as ```` ```ts ```` is not prose, and a rule that rewrote it would
+ * change what language a block claims to be.
+ *
+ * Linear in the length of the text: one pass over lines, and one regex walk per prose
+ * line.
+ */
+export function codeMask(text) {
+    const mask = new Uint8Array(text.length);
+    let pos = 0;
+    let fence = null;
+    for (const line of text.split('\n')) {
+        const opener = FENCE_RE.exec(line);
+        if (opener !== null) {
+            const marker = opener[1];
+            if (fence === null) {
+                fence = marker;
+            }
+            else if (marker[0] === fence[0] && marker.length >= fence.length) {
+                fence = null;
+            }
+            // `+ 1` covers the trailing newline. Without it the line breaks *between* fenced
+            // lines read as prose, and `lastProseBreakBefore` would happily choose one — which is
+            // exactly the mid-fence truncation it exists to prevent. Found by that test, not by
+            // reading this loop.
+            mask.fill(1, pos, pos + line.length + 1);
+        }
+        else if (fence !== null) {
+            mask.fill(1, pos, pos + line.length + 1);
+        }
+        else {
+            INLINE_CODE_RE.lastIndex = 0;
+            let match;
+            while ((match = INLINE_CODE_RE.exec(line)) !== null) {
+                mask.fill(1, pos + match.index, pos + match.index + match[0].length);
+            }
+        }
+        // +1 for the newline `split` consumed. The final line has no newline, but writing
+        // past the end of a `fill` range is a no-op, so no special case is needed.
+        pos += line.length + 1;
+    }
+    return mask;
+}
+/**
+ * Every inline code span outside a fenced block, in order of appearance.
+ *
+ * Spans *inside* a fence are not returned: their backticks are literal text there, and a
+ * caller rewriting one would be editing the contents of a code block.
+ */
+export function inlineCodeSpans(text) {
+    const spans = [];
+    let pos = 0;
+    let fence = null;
+    for (const line of text.split('\n')) {
+        const opener = FENCE_RE.exec(line);
+        if (opener !== null) {
+            const marker = opener[1];
+            if (fence === null)
+                fence = marker;
+            else if (marker[0] === fence[0] && marker.length >= fence.length)
+                fence = null;
+        }
+        else if (fence === null) {
+            INLINE_CODE_RE.lastIndex = 0;
+            let match;
+            while ((match = INLINE_CODE_RE.exec(line)) !== null) {
+                spans.push({
+                    start: pos + match.index,
+                    end: pos + match.index + match[0].length,
+                    content: match[2],
+                    ticks: match[1].length,
+                });
+            }
+        }
+        pos += line.length + 1;
+    }
+    return spans;
+}
+/**
+ * Rewrite the prose runs of a document, copying every code run byte-identical.
+ *
+ * `fn` is called once per maximal prose run. It may return text of any length — offsets
+ * are not preserved across the call, which is why the mask is computed once up front
+ * rather than consulted per match.
+ */
+export function mapProse(text, fn) {
+    const mask = codeMask(text);
+    const out = [];
+    let runStart = 0;
+    for (let i = 1; i <= text.length; i++) {
+        const boundary = i === text.length || mask[i] !== mask[runStart];
+        if (!boundary)
+            continue;
+        const run = text.slice(runStart, i);
+        out.push(mask[runStart] === 1 ? run : fn(run));
+        runStart = i;
+    }
+    return out.join('');
+}
+/**
+ * The last index at or before `limit` where a line break sits in **prose**.
+ *
+ * Used to choose a truncation point. A blank line inside a fenced block is masked as
+ * code, so restricting the cut to an unmasked newline is what stops truncation leaving a
+ * fence open — a body ending mid-fence renders the rest of the issue as one code block.
+ *
+ * Returns -1 when no such position exists, which the caller must treat as "cannot
+ * truncate safely" rather than as position 0.
+ */
+export function lastProseBreakBefore(text, limit) {
+    const mask = codeMask(text);
+    for (let i = Math.min(limit, text.length - 1); i >= 0; i--) {
+        if (text[i] === '\n' && mask[i] === 0)
+            return i;
+    }
+    return -1;
+}
+//# sourceMappingURL=markdown.js.map

package/dist/roadmap/sync/markdown.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdown.js","sourceRoot":"","sources":["../../../src/roadmap/sync/markdown.ts"],"names":[],"mappings":"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"}

package/dist/roadmap/sync/marker.d.ts

@@ -0,0 +1,47 @@
+/**
+ * The durable link between a roadmap item and its GitHub issue.
+ *
+ * The link is the item `id`, stamped on the issue as an HTML-comment marker. It is not
+ * the `remote:` frontmatter field: creating an issue and writing a local link are two
+ * writes to two systems, and every failure of the second leaves an issue with no link,
+ * which the next run turns into a duplicate. With the id living server-side there is no
+ * second write to fail, so the projection is a convergent rendering rather than
+ * stateful sync — and can be thrown away and rebuilt.
+ *
+ * Two properties matter and both are easy to get wrong:
+ *
+ * - **Matching is position-independent.** A created body ends with the marker, but as
+ *   soon as somebody comments or edits, it will not. Matching that depended on position
+ *   would silently stop finding issues the moment the tracker was used.
+ * - **Matching consumes the whole marker, terminator included.** The obvious
+ *   implementation, `body.includes(id)`, resolves `item-20260907-foo` against the issue
+ *   for `item-20260907-foo-2` — and that exact pair is manufactured by the roadmap
+ *   skill's own collision rule, which suffixes a duplicate slug with `-2`. So the id is
+ *   *extracted* and compared with `===`, never searched for as a substring.
+ *
+ * A third property was added by `richer-issue-bodies`:
+ *
+ * - **Matching is code-aware.** Once item prose is projected into the body, a marker
+ *   quoted inside a fence or an inline code span is *visible code*, not a comment —
+ *   GitHub renders it as text. A scanner that counted it would refuse runs as ambiguous
+ *   over something no reader sees as a marker. The corpus holds exactly one such
+ *   occurrence today, in a code span, so this is a measured case rather than a
+ *   hypothetical one. The invariant to keep is that the scanner and the renderer agree.
+ *
+ * Requirements: roadmap-issue-projection/AC-47, roadmap-issue-projection/AC-48,
+ * roadmap-issue-projection/AC-49, richer-issue-bodies/AC-15
+ *
+ * @module
+ */
+/** Render the marker for an item id. */
+export declare function renderMarker(id: string): string;
+/**
+ * Every item id marked in a body, in order of appearance, de-duplicated.
+ *
+ * Returns an **array** rather than the first id. A single-id return would make the
+ * two-markers case undetectable: the function would pick one and the projection would
+ * confidently retitle or close the wrong issue. The plural return costs nothing and
+ * makes the ambiguity representable, so `planProjection` can refuse instead of guess.
+ */
+export declare function findMarkerIds(body: string): string[];
+//# sourceMappingURL=marker.d.ts.map

package/dist/roadmap/sync/marker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"marker.d.ts","sourceRoot":"","sources":["../../../src/roadmap/sync/marker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAaH,wCAAwC;AACxC,wBAAgB,YAAY,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAE/C;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAapD"}

package/dist/roadmap/sync/marker.js

@@ -0,0 +1,73 @@
+/**
+ * The durable link between a roadmap item and its GitHub issue.
+ *
+ * The link is the item `id`, stamped on the issue as an HTML-comment marker. It is not
+ * the `remote:` frontmatter field: creating an issue and writing a local link are two
+ * writes to two systems, and every failure of the second leaves an issue with no link,
+ * which the next run turns into a duplicate. With the id living server-side there is no
+ * second write to fail, so the projection is a convergent rendering rather than
+ * stateful sync — and can be thrown away and rebuilt.
+ *
+ * Two properties matter and both are easy to get wrong:
+ *
+ * - **Matching is position-independent.** A created body ends with the marker, but as
+ *   soon as somebody comments or edits, it will not. Matching that depended on position
+ *   would silently stop finding issues the moment the tracker was used.
+ * - **Matching consumes the whole marker, terminator included.** The obvious
+ *   implementation, `body.includes(id)`, resolves `item-20260907-foo` against the issue
+ *   for `item-20260907-foo-2` — and that exact pair is manufactured by the roadmap
+ *   skill's own collision rule, which suffixes a duplicate slug with `-2`. So the id is
+ *   *extracted* and compared with `===`, never searched for as a substring.
+ *
+ * A third property was added by `richer-issue-bodies`:
+ *
+ * - **Matching is code-aware.** Once item prose is projected into the body, a marker
+ *   quoted inside a fence or an inline code span is *visible code*, not a comment —
+ *   GitHub renders it as text. A scanner that counted it would refuse runs as ambiguous
+ *   over something no reader sees as a marker. The corpus holds exactly one such
+ *   occurrence today, in a code span, so this is a measured case rather than a
+ *   hypothetical one. The invariant to keep is that the scanner and the renderer agree.
+ *
+ * Requirements: roadmap-issue-projection/AC-47, roadmap-issue-projection/AC-48,
+ * roadmap-issue-projection/AC-49, richer-issue-bodies/AC-15
+ *
+ * @module
+ */
+import { codeMask } from './markdown.js';
+/**
+ * Marker scanner.
+ *
+ * The id charset deliberately excludes `-->`'s characters, so the match cannot run past
+ * its own terminator. Global, because an issue carrying two markers is a real state the
+ * caller has to be able to see.
+ */
+const MARKER_RE = /<!--\s*aidlc-item:\s*([A-Za-z0-9][A-Za-z0-9._-]*)\s*-->/g;
+/** Render the marker for an item id. */
+export function renderMarker(id) {
+    return `<!-- aidlc-item: ${id} -->`;
+}
+/**
+ * Every item id marked in a body, in order of appearance, de-duplicated.
+ *
+ * Returns an **array** rather than the first id. A single-id return would make the
+ * two-markers case undetectable: the function would pick one and the projection would
+ * confidently retitle or close the wrong issue. The plural return costs nothing and
+ * makes the ambiguity representable, so `planProjection` can refuse instead of guess.
+ */
+export function findMarkerIds(body) {
+    const ids = [];
+    const mask = codeMask(body);
+    // `matchAll` on a fresh iterator each call — the regex is module-level and `g`-flagged,
+    // so relying on `lastIndex` across calls would make results depend on call order.
+    for (const match of body.matchAll(MARKER_RE)) {
+        // A marker inside a fence or an inline code span is code the reader can see, not a
+        // comment. Skipping it is what keeps this scanner in step with GitHub's renderer.
+        if (mask[match.index] === 1)
+            continue;
+        const id = match[1];
+        if (!ids.includes(id))
+            ids.push(id);
+    }
+    return ids;
+}
+//# sourceMappingURL=marker.js.map

package/dist/roadmap/sync/marker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"marker.js","sourceRoot":"","sources":["../../../src/roadmap/sync/marker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAEzC;;;;;;GAMG;AACH,MAAM,SAAS,GAAG,0DAA0D,CAAC;AAE7E,wCAAwC;AACxC,MAAM,UAAU,YAAY,CAAC,EAAU;IACrC,OAAO,oBAAoB,EAAE,MAAM,CAAC;AACtC,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,aAAa,CAAC,IAAY;IACxC,MAAM,GAAG,GAAa,EAAE,CAAC;IACzB,MAAM,IAAI,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC;IAC5B,wFAAwF;IACxF,kFAAkF;IAClF,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC;QAC7C,mFAAmF;QACnF,kFAAkF;QAClF,IAAI,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC;YAAE,SAAS;QACtC,MAAM,EAAE,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;QACpB,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC;YAAE,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACtC,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC"}

package/dist/roadmap/sync/plan.d.ts

@@ -0,0 +1,47 @@
+/**
+ * The projection planner. Pure — and the purity is the point.
+ *
+ * This module imports no `node:fs`, no `node:child_process`, and not `gh.ts`. A test
+ * pins that over the import graph, which is what makes "planning needs no network" a
+ * property of the code rather than a claim about the test suite: hand the command a
+ * runner that throws on every invocation and planning still succeeds, because the
+ * planner never had one.
+ *
+ * Refusals are **values**, in a fixed order, so a tree with two problems always yields
+ * the same message and the command layer — not this module — decides the exit code.
+ *
+ * Requirements: roadmap-issue-projection/AC-14 … roadmap-issue-projection/AC-32,
+ * roadmap-issue-projection/AC-44
+ *
+ * @module
+ */
+import { type BodyContext } from './body.js';
+import type { SyncConfig } from './config.js';
+import { type Plan, type ProjectableItem, type RemoteIssue, type UnprojectableRef } from './types.js';
+/** GitHub's own issue-title limit. */
+export declare const MAX_ISSUE_TITLE_LENGTH = 256;
+export interface PlanInput {
+    config: SyncConfig;
+    items: readonly ProjectableItem[];
+    unprojectable: readonly UnprojectableRef[];
+    issues: readonly RemoteIssue[];
+    retireIneligible: boolean;
+    /** Printed in the plan header and the prompt. */
+    repoLabel: string;
+    /**
+     * Everything body rendering needs. Required rather than defaulted: a silent default
+     * would render every body with no permalinks and no reference links, and nothing
+     * anywhere would say so.
+     */
+    bodyContext: BodyContext;
+}
+export type PlanResult = {
+    kind: 'ok';
+    plan: Plan;
+    warnings: readonly string[];
+} | {
+    kind: 'refused';
+    error: string;
+};
+export declare function planProjection(input: PlanInput): PlanResult;
+//# sourceMappingURL=plan.d.ts.map

package/dist/roadmap/sync/plan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan.d.ts","sourceRoot":"","sources":["../../../src/roadmap/sync/plan.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAGH,OAAO,EAAmD,KAAK,WAAW,EAAE,MAAM,WAAW,CAAC;AAC9F,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAG9C,OAAO,EAIL,KAAK,IAAI,EAET,KAAK,eAAe,EACpB,KAAK,WAAW,EAChB,KAAK,gBAAgB,EACtB,MAAM,YAAY,CAAC;AAEpB,sCAAsC;AACtC,eAAO,MAAM,sBAAsB,MAAM,CAAC;AAE1C,MAAM,WAAW,SAAS;IACxB,MAAM,EAAE,UAAU,CAAC;IACnB,KAAK,EAAE,SAAS,eAAe,EAAE,CAAC;IAClC,aAAa,EAAE,SAAS,gBAAgB,EAAE,CAAC;IAC3C,MAAM,EAAE,SAAS,WAAW,EAAE,CAAC;IAC/B,gBAAgB,EAAE,OAAO,CAAC;IAC1B,iDAAiD;IACjD,SAAS,EAAE,MAAM,CAAC;IAClB;;;;OAIG;IACH,WAAW,EAAE,WAAW,CAAC;CAC1B;AAED,MAAM,MAAM,UAAU,GAClB;IAAE,IAAI,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,IAAI,CAAC;IAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,GACvD;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAEvC,wBAAgB,cAAc,CAAC,KAAK,EAAE,SAAS,GAAG,UAAU,CAgE3D"}