peaks-loop 4.0.0-beta.8 → 4.0.1

package/dist/services/worktree/worktree-lease.js

@@ -0,0 +1,242 @@
+/**
+ * worktree-lease — pure-function lease store for `peaks worktree spawn`.
+ *
+ * Slice 2026-07-29-worktree-l2-extended Part 1. This is the Layer 2
+ * governance complement to Layer 3 (`permissions.deny` for the superpowers
+ * chain) and Layer 1 (sub-agent dispatch prompt refusal). Together the
+ * three layers close the superpowers-chain jailbreak that previously
+ * bypassed peaks-loop's worktree posture.
+ *
+ * The store is a pure function module: every helper takes the lease
+ * directory path as an argument and returns structured data. Atomic
+ * filesystem writes happen at the call site (CLI command), keeping the
+ * helpers trivially testable. The CLI surface lives in
+ * `src/cli/commands/worktree-spawn-commands.ts`.
+ *
+ * Why a separate lease (vs reusing `peaks worktree auth grant`):
+ * - `auth grant` is a single-shot, short-lived token file consulted by
+ *   the PreToolUse hook BEFORE `git worktree add` runs. It answers
+ *   "is the LLM allowed to do this right now?"
+ * - `lease` is a long-lived lifecycle object that owns the worktree
+ *   path, branch, expiry, and consumption log. It answers
+ *   "what worktrees does this session own, and which are still alive?"
+ * The two coexist: `spawn` writes a lease; the lease's existence
+ * implicitly authorizes worktree operations on its path (the hook
+ * integration is Part 2 of this slice).
+ */
+import { randomBytes } from 'node:crypto';
+import { posix as path } from 'node:path';
+/**
+ * Per-role default TTL. Sub-agent dispatch duration varies by role:
+ * - rd (long planning + impl) → 30 min
+ * - qa (test design + browser validation) → 15 min
+ * - ui (high-fidelity prototype iteration) → 1 h
+ * - txt (handoff capsule, no worktree expected) → n/a (no worktree)
+ * - general-purpose / unknown → 30 min (rd-like)
+ *
+ * Users MAY override with `--ttl <duration>` (e.g. `--ttl 4h`).
+ */
+export const DEFAULT_TTL_BY_ROLE = Object.freeze({
+    rd: 30 * 60 * 1_000,
+    qa: 15 * 60 * 1_000,
+    ui: 60 * 60 * 1_000,
+    sc: 30 * 60 * 1_000,
+    prd: 15 * 60 * 1_000,
+    general: 30 * 60 * 1_000
+});
+export const DEFAULT_TTL_MS = DEFAULT_TTL_BY_ROLE.rd;
+/**
+ * Compose a deterministic lease path under the per-session runtime dir.
+ * The function is pure: same inputs → same output. The caller passes
+ * `<sessionId>` (NOT a bare `<sid>` per the 2.7.1 single-scope-axis rule).
+ *
+ * Path layout:
+ *   .peaks/_runtime/<sessionId>/worktree-leases/<leaseId>.json
+ *
+ * The `worktree-leases/` directory is gitignored per the .peaks/_runtime/
+ * rule (committed in .gitignore for all runtime artifacts).
+ */
+export function leaseStoreDir(sessionRuntimeDir) {
+    return joinPath(sessionRuntimeDir, 'worktree-leases');
+}
+export function leaseFilePath(sessionRuntimeDir, leaseId) {
+    return joinPath(leaseStoreDir(sessionRuntimeDir), `${leaseId}.json`);
+}
+/**
+ * Compose the absolute worktree path (the `git worktree add <path>` target).
+ * Sits adjacent to the lease file under the same runtime dir.
+ */
+export function worktreePath(sessionRuntimeDir, leaseId) {
+    return joinPath(sessionRuntimeDir, 'worktrees', leaseId);
+}
+/**
+ * Generate a 16-hex lease id (8 random bytes, hex-encoded). The id is
+ * unique enough for the per-session scope; collisions across sessions
+ * are irrelevant because each session has its own lease directory.
+ */
+export function generateLeaseId() {
+    return randomBytes(8).toString('hex');
+}
+/**
+ * Compute the TTL ms for a role, falling back to DEFAULT_TTL_MS for
+ * unknown roles. The CLI overrides with `--ttl <ms>` when the user
+ * passes a positive value.
+ */
+export function ttlForRole(role) {
+    const normalized = role.toLowerCase();
+    const candidate = DEFAULT_TTL_BY_ROLE[normalized];
+    const fallback = DEFAULT_TTL_BY_ROLE['rd'] ?? 30 * 60 * 1_000;
+    return candidate ?? fallback;
+}
+/**
+ * Pure: produce a fresh `WorktreeLease` from a draft + status.
+ * `status` defaults to `'active'`; `consumedBySubAgents` defaults to [].
+ * Used by the CLI's atomicWriteJson call.
+ */
+export function finalizeLease(draft) {
+    return {
+        ...draft,
+        status: 'active',
+        consumedBySubAgents: []
+    };
+}
+/** Pure: lease status transitions to 'released'. Returns a new lease. */
+export function markReleased(lease) {
+    return { ...lease, status: 'released' };
+}
+/** Pure: lease status transitions to 'expired'. Returns a new lease. */
+export function markExpired(lease) {
+    return { ...lease, status: 'expired' };
+}
+/** Pure: lease status transitions to 'gc'. Returns a new lease. */
+export function markGc(lease) {
+    return { ...lease, status: 'gc' };
+}
+/** Pure: append a sub-agent batch / dispatch id to the consumption log. Returns a new lease. */
+export function recordConsumption(lease, subAgentId) {
+    if (lease.consumedBySubAgents.includes(subAgentId))
+        return lease;
+    return { ...lease, consumedBySubAgents: [...lease.consumedBySubAgents, subAgentId] };
+}
+/**
+ * Pure: is the lease still active (status === 'active' AND not past expiry).
+ * Expired leases are NOT auto-released; the gc CLI is the only path that
+ * transitions them to 'gc'. Until then, the on-disk state stays 'active'
+ * but `isLeaseActive` returns false so consumers skip the lease.
+ */
+export function isLeaseActive(lease, now = Date.now()) {
+    return lease.status === 'active' && lease.expiresAt > now;
+}
+/**
+ * List every lease file under the session's lease store dir.
+ *
+ * Pure with respect to its inputs: it does NOT sort or filter, and it
+ * does NOT mark anything expired. Callers (the `list` CLI) apply their
+ * own sort/filter and run `markExpired` lazily.
+ */
+export function listLeasesSync(storeDir, fs) {
+    if (!fs.existsSync(storeDir)) {
+        return { kind: 'store-missing', storeDir };
+    }
+    const files = fs.readdir(storeDir).filter((f) => f.endsWith('.json'));
+    const leases = [];
+    const errors = [];
+    for (const f of files) {
+        const file = `${storeDir.replace(/[\\/]+$/, '')}/${f}`;
+        try {
+            leases.push(deserializeLease(fs.readFile(file)));
+        }
+        catch (err) {
+            errors.push({ file, error: err instanceof Error ? err.message : String(err) });
+        }
+    }
+    return { kind: 'ok', leases, errors };
+}
+/**
+ * Pure: a lease is eligible for `gc` if its status is one of {released,
+ * expired} AND its worktree path is no longer attached to git (`git
+ * worktree list` would not include it). The CLI re-checks with git and
+ * uses this helper as a coarse pre-filter.
+ */
+export function isLeaseGcEligible(lease, now = Date.now()) {
+    if (lease.status === 'gc')
+        return false;
+    if (lease.status === 'released')
+        return true;
+    // status === 'active' but past expiry → treat as expired candidate
+    return lease.expiresAt <= now;
+}
+/**
+ * Pure: derive a new lease from an existing one with an extended
+ * `expiresAt`. Other fields are preserved. The CLI writes the new lease
+ * atomically. Used by `peaks worktree renew --lease-id <id> --ttl <ms>`.
+ */
+export function renewLease(lease, newExpiresAt) {
+    return { ...lease, expiresAt: newExpiresAt, status: 'active' };
+}
+/**
+ * Pure: serialize a lease to JSON with stable field order (deterministic
+ * output for diff-friendly audit logs). The CLI passes the result to
+ * `atomicWriteJson`. The function does NOT mutate the input.
+ */
+export function serializeLease(lease) {
+    return JSON.stringify(lease, null, 2) + '\n';
+}
+/**
+ * Pure: deserialize a lease from JSON. Throws on malformed input — the
+ * CLI catches and returns a `LEASE_FILE_INVALID` envelope (mirroring the
+ * `peaks worktree auth` FILE_INVALID convention).
+ */
+export function deserializeLease(raw) {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== 'object' || parsed === null) {
+        throw new Error('lease file must contain a JSON object');
+    }
+    const obj = parsed;
+    if (typeof obj.leaseId !== 'string')
+        throw new Error('leaseId missing');
+    if (typeof obj.rid !== 'string')
+        throw new Error('rid missing');
+    if (typeof obj.role !== 'string')
+        throw new Error('role missing');
+    if (typeof obj.path !== 'string')
+        throw new Error('path missing');
+    if (typeof obj.branch !== 'string')
+        throw new Error('branch missing');
+    if (typeof obj.createdAt !== 'number')
+        throw new Error('createdAt missing');
+    if (typeof obj.expiresAt !== 'number')
+        throw new Error('expiresAt missing');
+    if (typeof obj.purpose !== 'string')
+        throw new Error('purpose missing');
+    if (typeof obj.status !== 'string')
+        throw new Error('status missing');
+    if (!Array.isArray(obj.consumedBySubAgents))
+        throw new Error('consumedBySubAgents missing');
+    return {
+        leaseId: obj.leaseId,
+        rid: obj.rid,
+        role: obj.role,
+        path: obj.path,
+        branch: obj.branch,
+        createdAt: obj.createdAt,
+        expiresAt: obj.expiresAt,
+        purpose: obj.purpose,
+        status: obj.status,
+        consumedBySubAgents: obj.consumedBySubAgents
+    };
+}
+/** Internal: normalize a path segment to forward slashes (Windows
+ *  callers pass `C:\Users\...`; posix.join sees the backslash and
+ *  silently mangles). Then posix-join. The CLI uses the same module
+ *  so reads + writes always agree. */
+function joinPath(...segments) {
+    if (segments.length === 0)
+        return '';
+    const normalized = segments.map((s) => s.replace(/\\/g, '/'));
+    let acc = normalized[0];
+    for (let i = 1; i < normalized.length; i++) {
+        acc = path.join(acc, normalized[i]);
+    }
+    return acc;
+}

package/dist/shared/format-md-compact.d.ts

@@ -0,0 +1,32 @@
+/**
+ * format-md-compact — single source of truth for whitespace / decoration
+ * normalization across every CLI body-output path.
+ *
+ * Slice 023 (R3) — `peaks project memories:show`, `peaks retrospective show`,
+ * and `peaks request show` (per-artifact) all funnel their `body` field through
+ * this helper so the LLM-consumed output is free of blank-line padding,
+ * decorative `---` rules, and frontmatter `description:` field-name repeats
+ * while preserving every semantically meaningful construct (code fences,
+ * setext heading underlines, GFM table syntax, frontmatter, list indentation,
+ * inline emphasis, code spans).
+ *
+ * Pure function: no fs, no I/O. Easy to unit-test (see
+ * `tests/unit/shared/format-md-compact.test.ts`).
+ */
+export interface FormatMdCompactOptions {
+    /** Preserve code-fence (``` ... ```) and frontmatter (--- ... ---) content. Default true. */
+    preserveCodeBlocks?: boolean;
+    /** Preserve setext heading underlines (===, --- under a text line). Default true. */
+    preserveSetextHeadings?: boolean;
+    /** Preserve GFM table syntax (| ... | rows). Default true. */
+    preserveTables?: boolean;
+    /** Collapse 3+ blank lines to 1. Default true. */
+    collapseBlankLines?: boolean;
+    /** Strip trailing whitespace per line. Default true. */
+    stripTrailingWhitespace?: boolean;
+    /** Strip decorative `---` lines (lines surrounded by blanks OR trailing final line). Default true. */
+    stripDecorativeHorizontalRules?: boolean;
+    /** Strip frontmatter `description:` field-name repeat when same value already in body header. Default true. */
+    stripFrontmatterDescriptionRepeat?: boolean;
+}
+export declare function formatMdCompact(input: string, options?: FormatMdCompactOptions): string;

package/dist/shared/format-md-compact.js

@@ -0,0 +1,297 @@
+/**
+ * format-md-compact — single source of truth for whitespace / decoration
+ * normalization across every CLI body-output path.
+ *
+ * Slice 023 (R3) — `peaks project memories:show`, `peaks retrospective show`,
+ * and `peaks request show` (per-artifact) all funnel their `body` field through
+ * this helper so the LLM-consumed output is free of blank-line padding,
+ * decorative `---` rules, and frontmatter `description:` field-name repeats
+ * while preserving every semantically meaningful construct (code fences,
+ * setext heading underlines, GFM table syntax, frontmatter, list indentation,
+ * inline emphasis, code spans).
+ *
+ * Pure function: no fs, no I/O. Easy to unit-test (see
+ * `tests/unit/shared/format-md-compact.test.ts`).
+ */
+const FENCE_TRIPLE_BACKTICK = '```';
+const FENCE_TRIPLE_TILDE = '~~~';
+const FENCE_MARKER_RE = /^(```+|~~~+)/;
+const TABLE_ROW_RE = /^\s*\|.*\|\s*$/;
+const TABLE_ALIGN_ROW_RE = /^\s*\|?\s*:?-{1,}:?\s*(\|\s*:?-{1,}:?\s*)+\|?\s*$/;
+const ATX_HEADING_RE = /^#{1,6}\s/;
+const HEADING_LINE_RE = /^\S/;
+const SETEXT_UNDERLINE_RE = /^=+\s*$|^-{2,}\s*$/;
+export function formatMdCompact(input, options = {}) {
+    if (input.length === 0)
+        return input;
+    const opts = {
+        preserveCodeBlocks: options.preserveCodeBlocks ?? true,
+        preserveSetextHeadings: options.preserveSetextHeadings ?? true,
+        preserveTables: options.preserveTables ?? true,
+        collapseBlankLines: options.collapseBlankLines ?? true,
+        stripTrailingWhitespace: options.stripTrailingWhitespace ?? true,
+        stripDecorativeHorizontalRules: options.stripDecorativeHorizontalRules ?? true,
+        stripFrontmatterDescriptionRepeat: options.stripFrontmatterDescriptionRepeat ?? true
+    };
+    // 1. Split frontmatter from body (if any). The YAML block lives between
+    //    the first line `---` and the second line `---`. We carry it through
+    //    unchanged.
+    const fm = splitFrontmatter(input);
+    const body = fm.body;
+    // 2. Walk the body line-by-line, applying the protected-zone rules.
+    const normalizedBody = normalizeBody(body, opts);
+    // 3. Optional frontmatter `description:` repeat strip. The body's
+    //    first ATX heading is compared to the frontmatter `description:`
+    //    value; if the description text repeats the heading, the leading
+    //    paragraph is dropped. Implemented as a one-shot post-pass.
+    const finalBody = opts.stripFrontmatterDescriptionRepeat
+        ? stripDescriptionRepeat(normalizedBody, fm.description)
+        : normalizedBody;
+    // 4. Re-assemble. The frontmatter stays verbatim; the body carries the
+    //    normalized text. Match the original layout: if the input had
+    //    frontmatter, output is `frontmatter + blank + body`; otherwise
+    //    the body is the whole output.
+    if (fm.raw === '') {
+        return finalBody;
+    }
+    return fm.raw + '\n' + finalBody;
+}
+function splitFrontmatter(input) {
+    // Normalize line endings so Windows \r\n doesn't confuse the leading-marker check.
+    const normalized = input.replace(/\r\n/g, '\n');
+    const lines = normalized.split('\n');
+    if (lines[0] !== '---') {
+        return { raw: '', description: null, body: normalized };
+    }
+    let closeIndex = -1;
+    for (let index = 1; index < lines.length; index += 1) {
+        if (lines[index] === '---') {
+            closeIndex = index;
+            break;
+        }
+    }
+    if (closeIndex < 0) {
+        return { raw: '', description: null, body: normalized };
+    }
+    const raw = lines.slice(0, closeIndex + 1).join('\n');
+    // Body = everything after the closing `---` (preserving one optional blank line).
+    const bodyLines = lines.slice(closeIndex + 1);
+    while (bodyLines.length > 0 && bodyLines[0] === '') {
+        bodyLines.shift();
+    }
+    const body = bodyLines.join('\n');
+    // Extract the `description:` field. Walk the YAML block; pull the value
+    // as a single-line string. Multi-line (`|`) or folded (`>`) scalars are
+    // joined with a single space — the description is a short summary, the
+    // exact whitespace inside the block scalar is not preserved.
+    const frontmatterLines = lines.slice(1, closeIndex);
+    const description = extractFrontmatterDescription(frontmatterLines);
+    return { raw, description, body };
+}
+function extractFrontmatterDescription(frontmatterLines) {
+    for (let index = 0; index < frontmatterLines.length; index += 1) {
+        const line = frontmatterLines[index] ?? '';
+        const match = line.match(/^description:\s*(.*)$/);
+        if (match === null)
+            continue;
+        const inline = (match[1] ?? '').trim();
+        if (inline === '|' || inline === '>') {
+            const collected = [];
+            for (let inner = index + 1; inner < frontmatterLines.length; inner += 1) {
+                const innerLine = frontmatterLines[inner] ?? '';
+                if (/^[A-Za-z0-9_-]+:/.test(innerLine))
+                    break;
+                collected.push(innerLine.replace(/^\s{2}/, ''));
+            }
+            return collected.join(' ').trim();
+        }
+        // Strip surrounding quotes if the value is a quoted scalar.
+        return inline.replace(/^['"]|['"]$/g, '');
+    }
+    return null;
+}
+function normalizeBody(body, opts) {
+    // Walk line-by-line, tracking the protected-zone flags and emitting a
+    // transformed line stream. We keep three flag bits:
+    //   insideFence:   toggled on ``` / ~~~ lines
+    //   insideFrontmatterYAML: handled by splitFrontmatter; body has none.
+    //   insideTable:   detected by leading-pipe; carried until first non-pipe
+    //                  line.
+    const lines = body.split('\n');
+    // 1. Pre-pass: compute the `setextUnderlined` markers so the decorative
+    //    `---` strip can know when a line is a setext H2 underline (semantic)
+    //    vs a decoration.
+    const setextUnderlined = computeSetextUnderlines(lines);
+    const protection = [];
+    let insideFence = false;
+    let insideTable = false;
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index] ?? '';
+        if (opts.preserveCodeBlocks && isFenceOpenLine(line) && !isFenceCloseLine(line, insideFence)) {
+            insideFence = !insideFence;
+            protection.push('fence');
+            continue;
+        }
+        if (insideFence) {
+            protection.push('fence');
+            continue;
+        }
+        if (opts.preserveSetextHeadings && setextUnderlined.has(index)) {
+            protection.push('setext');
+            continue;
+        }
+        if (opts.preserveTables && isTableLine(line)) {
+            // Entering / continuing a table — first row that looks like a table
+            // starts the table zone; the alignment row (|---|) is included.
+            insideTable = true;
+            protection.push('table');
+            continue;
+        }
+        if (insideTable && !isTableLine(line) && line.trim() !== '') {
+            insideTable = false;
+        }
+        if (insideTable) {
+            protection.push('table');
+            continue;
+        }
+        protection.push('plain');
+    }
+    // 3. Per-line transforms: strip trailing whitespace outside protected
+    //    zones; strip decorative `---` outside setext / table / fence zones.
+    const out = [];
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index] ?? '';
+        const zone = protection[index] ?? 'plain';
+        let transformed = line;
+        if (zone !== 'fence' && opts.stripTrailingWhitespace) {
+            transformed = transformed.replace(/[ \t]+$/u, '');
+        }
+        if (zone !== 'fence' &&
+            zone !== 'setext' &&
+            zone !== 'table' &&
+            opts.stripDecorativeHorizontalRules) {
+            if (isDecorativeHorizontalRule(transformed)) {
+                // Mark for removal: push a sentinel. The blank-line collapse step
+                // will merge surrounding blanks.
+                transformed = '__PEAKS_HR_REMOVED__';
+            }
+        }
+        out.push(transformed);
+    }
+    // 4. Drop the sentinel lines (decorative `---` after classification).
+    let collapsed = out.filter((line) => line !== '__PEAKS_HR_REMOVED__');
+    // 5. Collapse 3+ consecutive blank lines into 1. Two blank lines
+    //    between two non-blank lines are also collapsed to 1 (matches PRD
+    //    R2's "decorative `---` is redundant" rule — the original visual
+    //    gap that surrounded the `---` collapses with it).
+    if (opts.collapseBlankLines) {
+        collapsed = collapseMultiBlanks(collapsed);
+    }
+    return collapsed.join('\n');
+}
+function isFenceOpenLine(line) {
+    return FENCE_MARKER_RE.test(line);
+}
+function isFenceCloseLine(line, insideFence) {
+    // The `isFenceOpenLine` already returned true for this line, so it
+    // starts with ``` or ~~~. A "close" line is one that opens a new fence
+    // of the *same* length. We approximate by treating any opener as a close
+    // when we are currently inside a fence.
+    return insideFence;
+}
+function isTableLine(line) {
+    return TABLE_ROW_RE.test(line) || TABLE_ALIGN_ROW_RE.test(line);
+}
+function computeSetextUnderlines(lines) {
+    // A `===` or `---` line is a setext heading underline ONLY when it sits
+    // directly under a non-blank, non-ATX text line (no blank line between
+    // them). The presence of a blank line between the text and the rule
+    // disqualifies it (a blank-separated `---` is decoration, not setext).
+    const result = new Set();
+    for (let index = 1; index < lines.length; index += 1) {
+        const line = lines[index] ?? '';
+        if (!SETEXT_UNDERLINE_RE.test(line))
+            continue;
+        const prev = lines[index - 1] ?? '';
+        if (prev === '')
+            continue;
+        if (ATX_HEADING_RE.test(prev))
+            continue;
+        if (!HEADING_LINE_RE.test(prev))
+            continue;
+        result.add(index);
+    }
+    return result;
+}
+function isDecorativeHorizontalRule(line) {
+    // A line that is exactly `---` (or any number of `-` chars) is a
+    // candidate horizontal rule. The caller has already excluded setext
+    // and table contexts via the `protection` array.
+    return /^-+$/.test(line);
+}
+function collapseMultiBlanks(lines) {
+    const result = [];
+    let blankRun = 0;
+    for (const line of lines) {
+        if (line === '') {
+            blankRun += 1;
+            // 1 blank line is the cap. Drop the rest.
+            if (blankRun <= 1) {
+                result.push(line);
+            }
+            continue;
+        }
+        blankRun = 0;
+        result.push(line);
+    }
+    return result;
+}
+function stripDescriptionRepeat(body, description) {
+    if (description === null || description.length === 0)
+        return body;
+    // Find the first ATX heading line. If it equals the frontmatter
+    // description text, drop it. Also drop a description-matching paragraph
+    // that immediately follows the heading (PRD's "frontmatter description
+    // already in body header" case). All other content is preserved.
+    const lines = body.split('\n');
+    if (lines.length === 0)
+        return body;
+    let firstHeadingIndex = -1;
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index] ?? '';
+        if (line.trim() === '')
+            continue;
+        if (ATX_HEADING_RE.test(line)) {
+            firstHeadingIndex = index;
+        }
+        break;
+    }
+    if (firstHeadingIndex < 0)
+        return body;
+    const headingText = (lines[firstHeadingIndex] ?? '').replace(/^#{1,6}\s+/, '').trim();
+    if (headingText !== description)
+        return body;
+    // Walk past the heading, then past any blank lines, then past the
+    // matching description paragraph (if present). Anything after the
+    // description paragraph is the body we want to keep.
+    const tail = lines.slice(firstHeadingIndex + 1);
+    let cursor = 0;
+    // Skip blanks.
+    while (cursor < tail.length && (tail[cursor] ?? '') === '') {
+        cursor += 1;
+    }
+    // Read the first non-blank paragraph.
+    const paragraphStart = cursor;
+    while (cursor < tail.length && (tail[cursor] ?? '') !== '') {
+        cursor += 1;
+    }
+    const paragraph = tail.slice(paragraphStart, cursor);
+    if (paragraph.join(' ').trim() !== description) {
+        // The paragraph doesn't match the description — don't drop it.
+        cursor = paragraphStart;
+    }
+    const kept = tail.slice(cursor);
+    if (kept.length === 0)
+        return '';
+    return kept.join('\n');
+}

package/dist/shared/frontmatter.d.ts

@@ -0,0 +1,6 @@
+export type SkillFrontmatter = {
+    name: string;
+    description: string;
+    [key: string]: string;
+};
+export declare function parseFrontmatter(markdown: string): SkillFrontmatter;