peaks-loop 4.0.54 → 4.1.1

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

@@ -0,0 +1,125 @@
+/**
+ * Internal, finding-free building blocks for `format-md-compact.ts`.
+ *
+ * Split verbatim from the main module for the file-size cap campaign; the
+ * public surface (`formatMdCompact` / `FormatMdCompactOptions`) is re-exported
+ * from `format-md-compact.ts`, so importers keep pointing at the same path.
+ * This module is imported by both `src/` and `packages/` through that path.
+ */
+export const FENCE_MARKER_RE = /^(```+|~~~+)/;
+export const TABLE_ROW_RE = /^\s*\|.*\|\s*$/;
+export const TABLE_ALIGN_ROW_RE = /^\s*\|?\s*:?-{1,}:?\s*(\|\s*:?-{1,}:?\s*)+\|?\s*$/;
+export const ATX_HEADING_RE = /^#{1,6}\s/;
+export const HEADING_LINE_RE = /^\S/;
+export const SETEXT_UNDERLINE_RE = /^=+\s*$|^-{2,}\s*$/;
+export 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;
+}
+export function isFenceOpenLine(line) {
+    return FENCE_MARKER_RE.test(line);
+}
+export 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;
+}
+export function isTableLine(line) {
+    return TABLE_ROW_RE.test(line) || TABLE_ALIGN_ROW_RE.test(line);
+}
+export 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;
+}
+export 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);
+}
+export 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;
+}

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

@@ -13,14 +13,9 @@
  * Pure function: no fs, no I/O. Easy to unit-test (see
  * `tests/unit/shared/format-md-compact.test.ts`).
  */
+import { ATX_HEADING_RE, collapseMultiBlanks, computeSetextUnderlines, isDecorativeHorizontalRule, isFenceCloseLine, isFenceOpenLine, isTableLine, splitFrontmatter } from './format-md-compact-internals.js';
 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;
@@ -56,60 +51,6 @@ export function formatMdCompact(input, options = {}) {
     }
     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:
@@ -189,63 +130,6 @@ function normalizeBody(body, opts) {
     }
     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;

package/dist/shared/fs-utils.js

@@ -45,7 +45,8 @@ export function readDirectoryLinkTarget(linkPath) {
     try {
         return readlinkSync(linkPath);
     }
-    catch { // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
+    catch {
+        // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
         return null;
     }
 }

package/dist/shared/incrementing-number.js

@@ -15,15 +15,15 @@ import { join } from 'node:path';
 export function getNextNumber(dirPath) {
     if (!existsSync(dirPath))
         return 1;
-    const files = readdirSync(dirPath).filter(f => f.endsWith('.md'));
+    const files = readdirSync(dirPath).filter((f) => f.endsWith('.md'));
     if (files.length === 0)
         return 1;
     const numbers = files
-        .map(f => {
+        .map((f) => {
         const match = /^(\d+)-/.exec(f);
         return match && match[1] ? parseInt(match[1], 10) : NaN;
     })
-        .filter(n => !isNaN(n));
+        .filter((n) => !isNaN(n));
     return numbers.length > 0 ? Math.max(...numbers) + 1 : 1;
 }
 /**

package/dist/shared/json-parse.d.ts

@@ -0,0 +1,71 @@
+/**
+ * `JSON.parse`, with the shape CHECKED before the value is used.
+ *
+ * WHY THIS EXISTS (S12, 2026-09-20). `lib.es5.d.ts` declares
+ * `JSON.parse(text: string): any`, so every unvalidated parse is a place where
+ * `any` ENTERS a file and then flows outward — at the S12 census that was ~448
+ * `@typescript-eslint/no-unsafe-*` findings across 48 files, the largest single
+ * root of the TS `any` population. The findings sit downstream of the parse;
+ * the parse is what has to change.
+ *
+ * WHAT THIS IS NOT. The shortest-looking fix is
+ *
+ *     function parseJson<T>(raw: string): T { return JSON.parse(raw) as T; }
+ *
+ * It has a type parameter and reads as "typed", but it validates nothing: the
+ * `as T` is still there, wearing a costume. That is the same offence as a
+ * suppression comment and harder to see, and S12 forbids it outright.
+ *
+ * So the type parameter here is the SCHEMA, not the result. `z.infer<S>` is
+ * derived FROM the schema that actually ran, which is why the returned type is
+ * a claim the runtime already checked rather than an assertion about it.
+ *
+ * Sibling precedent: `src/shared/array-guards.ts` (S10) returns plain
+ * `boolean` rather than a `value is T[]` predicate for the same reason.
+ */
+import type { z } from 'zod';
+/**
+ * Parse `raw` and return it only if it matches `schema`. Throws (from
+ * `schema.parse`) when the text is not JSON, or is JSON of the wrong shape.
+ * Use where a malformed value is a defect that must be visible.
+ */
+export declare function parseJson<S extends z.ZodType>(raw: string, schema: S): z.infer<S>;
+/**
+ * The outcome of {@link tryParseJson}. A DISCRIMINATED result rather than
+ * `T | null`, because "the text is not JSON" and "the text is JSON of the wrong
+ * shape" are different failures and a caller that must treat them differently
+ * has to be able to say so.
+ *
+ * WHY NOT `T | null` (2026-09-23). Collapsing both to `null` is precisely the
+ * shape this repository's own `catch-return-null` ratchet exists to catch —
+ * "caller cannot distinguish failure from success" — and it had already cost a
+ * real defect rather than merely risking one. `readJsonIfExists` in
+ * `src/services/sediment/pool-read.ts` had no `catch` and THREW on malformed
+ * JSON, so replacing it with the `T | null` form silently downgraded "the whole
+ * command fails" to "this bee is skipped". Neither primitive could restore the
+ * pair — the old `tryParseJson` mapped both failures to `null`, and `parseJson`
+ * throws on both — so that reader had to hand-roll its parse in two steps. The
+ * user adjudicated on 2026-09-21 that parsing must fail loudly while a wrong
+ * shape is skipped; `reason` is what finally lets a caller reproduce that pair
+ * without hand-rolling it. See
+ * `tests/unit/services/sediment/pool-read-semantics.test.ts`.
+ */
+export type TryParse<S extends z.ZodType> = {
+    ok: true;
+    value: z.infer<S>;
+} | {
+    ok: false;
+    reason: 'malformed' | 'shape';
+};
+/**
+ * Parse `raw` into `schema`, reporting WHICH failure occurred when it fails.
+ * Never throws: `malformed` is text that is not JSON, `shape` is JSON the
+ * schema rejected.
+ *
+ * Callers whose two failures are the same outcome collapse it at their own call
+ * site (`r.ok ? r.value : null`) — visibly, and outside a `catch` — which is
+ * the shape those file-backed readers already had. Callers that must keep the
+ * failures apart switch on `reason`. Use `parseJson` when every failure is a
+ * defect that must be visible.
+ */
+export declare function tryParseJson<S extends z.ZodType>(raw: string, schema: S): TryParse<S>;

package/dist/shared/json-parse.js

@@ -0,0 +1,32 @@
+/**
+ * Parse `raw` and return it only if it matches `schema`. Throws (from
+ * `schema.parse`) when the text is not JSON, or is JSON of the wrong shape.
+ * Use where a malformed value is a defect that must be visible.
+ */
+export function parseJson(raw, schema) {
+    // No cast: `JSON.parse`'s `any` is accepted by `parse`'s `unknown` parameter,
+    // and `schema.parse` establishes the return type by checking it.
+    return schema.parse(JSON.parse(raw));
+}
+/**
+ * Parse `raw` into `schema`, reporting WHICH failure occurred when it fails.
+ * Never throws: `malformed` is text that is not JSON, `shape` is JSON the
+ * schema rejected.
+ *
+ * Callers whose two failures are the same outcome collapse it at their own call
+ * site (`r.ok ? r.value : null`) — visibly, and outside a `catch` — which is
+ * the shape those file-backed readers already had. Callers that must keep the
+ * failures apart switch on `reason`. Use `parseJson` when every failure is a
+ * defect that must be visible.
+ */
+export function tryParseJson(raw, schema) {
+    let decoded;
+    try {
+        decoded = JSON.parse(raw);
+    }
+    catch {
+        return { ok: false, reason: 'malformed' };
+    }
+    const result = schema.safeParse(decoded);
+    return result.success ? { ok: true, value: result.data } : { ok: false, reason: 'shape' };
+}

package/dist/shared/json-schema-mini.js

@@ -49,7 +49,9 @@ function validateNode(value, schema, path, errors) {
             branchErrors.push(sink);
         }
         if (!matched) {
-            const detail = branchErrors.map((sink) => sink.map((issue) => issue.message).join(' / ')).join(' | ');
+            const detail = branchErrors
+                .map((sink) => sink.map((issue) => issue.message).join(' / '))
+                .join(' | ');
             errors.push({ path, message: `does not match any oneOf branch (${detail})` });
         }
         return;

package/dist/shared/path-safety.js

@@ -25,7 +25,9 @@ function hasUnsafePathShape(input) {
         return true;
     if (/^[^@\s]+@[^:\s]+:.+/.test(normalized))
         return true;
-    return normalized.split('/').some((segment) => segment.length === 0 || segment === '.' || segment === '..');
+    return normalized
+        .split('/')
+        .some((segment) => segment.length === 0 || segment === '.' || segment === '..');
 }
 export function isUnsafePathInput(input) {
     return hasUnsafePathShape(input);

package/dist/shared/path-utils.d.ts

@@ -2,6 +2,26 @@ import { type Platform } from './platform.js';
 export declare const SEP: "\\" | "/";
 export declare function normalizePath(p: string): string;
 export declare function pathsEqual(a: string, b: string): boolean;
+/**
+ * The comparison key for a file path that must survive a different checkout:
+ * repo-relative with POSIX separators.
+ *
+ * Rationale (lint baseline, measured 2026-09-25): ESLint reports `filePath`
+ * absolute for the machine it ran on (`D:\peaks-loop\src\cli\commands\…`),
+ * a committed baseline has to mean the same file on a *different* root, and
+ * `git diff` reports repo-relative paths. Comparing those forms by `!==` is
+ * false on every machine — which silently made both the baseline waiver and
+ * the diff gate inert. Every side of every such comparison must be reduced
+ * through this one function; reducing only one side is the same defect with
+ * an extra step.
+ *
+ * A path that cannot be expressed relative to `projectRoot` — another drive,
+ * or an already-relative key — is returned normalized-but-absolute, so it
+ * still compares consistently: it simply will not match a path rooted
+ * elsewhere. That is deliberate. A stale absolute key keeps working on the
+ * machine that wrote it and stays inert everywhere else, exactly as before.
+ */
+export declare function repoRelativeKey(filePath: string, projectRoot: string): string;
 export declare function localPath(p: string, targetPlatform?: Platform): string;
 export declare function getTempDir(options?: {
     env?: NodeJS.ProcessEnv;

package/dist/shared/path-utils.js

@@ -14,6 +14,32 @@ export function normalizePath(p) {
 export function pathsEqual(a, b) {
     return normalizePath(a) === normalizePath(b);
 }
+/**
+ * The comparison key for a file path that must survive a different checkout:
+ * repo-relative with POSIX separators.
+ *
+ * Rationale (lint baseline, measured 2026-09-25): ESLint reports `filePath`
+ * absolute for the machine it ran on (`D:\peaks-loop\src\cli\commands\…`),
+ * a committed baseline has to mean the same file on a *different* root, and
+ * `git diff` reports repo-relative paths. Comparing those forms by `!==` is
+ * false on every machine — which silently made both the baseline waiver and
+ * the diff gate inert. Every side of every such comparison must be reduced
+ * through this one function; reducing only one side is the same defect with
+ * an extra step.
+ *
+ * A path that cannot be expressed relative to `projectRoot` — another drive,
+ * or an already-relative key — is returned normalized-but-absolute, so it
+ * still compares consistently: it simply will not match a path rooted
+ * elsewhere. That is deliberate. A stale absolute key keeps working on the
+ * machine that wrote it and stays inert everywhere else, exactly as before.
+ */
+export function repoRelativeKey(filePath, projectRoot) {
+    const normalized = normalizePath(filePath);
+    if (!isAbsolute(filePath))
+        return normalized.replace(/^\.\//, '');
+    const rel = normalizePath(relative(projectRoot, filePath));
+    return rel.length === 0 || rel.startsWith('..') || isAbsolute(rel) ? normalized : rel;
+}
 export function localPath(p, targetPlatform = platform) {
     return localPathConverters[targetPlatform](p);
 }

package/dist/shared/planner-response.js

@@ -5,20 +5,20 @@
  */
 export const WORKSPACE_UNAVAILABLE_NEXT_ACTIONS = Object.freeze([
     'Configure a Peaks artifact workspace in your workspace config.',
-    'See peaks artifacts workspace --help for setup instructions.',
+    'See peaks artifacts workspace --help for setup instructions.'
 ]);
 export function makeUnavailableResponse(behavior, reason) {
     return {
         available: false,
         behavior,
         reason,
-        nextActions: [...WORKSPACE_UNAVAILABLE_NEXT_ACTIONS],
+        nextActions: [...WORKSPACE_UNAVAILABLE_NEXT_ACTIONS]
     };
 }
 export function makeAvailableResponse(data) {
     return {
         available: true,
-        data,
+        data
     };
 }
 export function isUnavailableResponse(resp) {

package/dist/shared/stale-policy.js

@@ -66,9 +66,7 @@ export function applyStalePolicy(entries, options = {}) {
         const ageDays = Math.max(0, Math.floor((now - parsed) / DAY_MS));
         return { ...entry, stale, ageDays };
     });
-    const filtered = includeStale
-        ? annotated
-        : annotated.filter((entry) => !entry.stale);
+    const filtered = includeStale ? annotated : annotated.filter((entry) => !entry.stale);
     return {
         entries: filtered,
         droppedCount: annotated.length - filtered.length,

package/dist/skills/peaks-maker/index.js

@@ -1,14 +1,14 @@
 // src/skills/peaks-maker/index.ts
-import { readFileSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-import { dirname, join } from "node:path";
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
 function parseFrontmatter(md) {
     const m = md.match(/^---\n([\s\S]+?)\n---\n([\s\S]*)$/);
     if (!m)
-        throw new Error("peaks-maker SKILL.md is missing YAML frontmatter");
+        throw new Error('peaks-maker SKILL.md is missing YAML frontmatter');
     const fm = {};
-    for (const line of m[1].split("\n")) {
-        const i = line.indexOf(":");
+    for (const line of m[1].split('\n')) {
+        const i = line.indexOf(':');
         if (i > 0)
             fm[line.slice(0, i).trim()] = line.slice(i + 1).trim();
     }
@@ -19,14 +19,14 @@ function parseFrontmatter(md) {
     // so a missing/empty key surfaces as a clear error at module-load time.
     const name = fm.name;
     const description = fm.description;
-    if (typeof name !== "string" || name.length === 0) {
-        throw new Error("peaks-maker SKILL.md is missing name or description in frontmatter");
+    if (typeof name !== 'string' || name.length === 0) {
+        throw new Error('peaks-maker SKILL.md is missing name or description in frontmatter');
     }
-    if (typeof description !== "string" || description.length === 0) {
-        throw new Error("peaks-maker SKILL.md is missing name or description in frontmatter");
+    if (typeof description !== 'string' || description.length === 0) {
+        throw new Error('peaks-maker SKILL.md is missing name or description in frontmatter');
     }
     return { name, description, body: m[2] };
 }
 const here = dirname(fileURLToPath(import.meta.url));
-const md = readFileSync(join(here, "SKILL.md"), "utf-8");
+const md = readFileSync(join(here, 'SKILL.md'), 'utf-8');
 export const peaksMakerManifest = parseFrontmatter(md);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "peaks-loop",
-  "version": "4.0.54",
+  "version": "4.1.1",
   "description": "Loop Engineering CLI — workflow primitive / loop guards / evaluators / slice orchestration",
   "author": "SquabbyZ",
   "keywords": [
@@ -83,12 +83,27 @@
     "schemas/*.json",
     ".claude-plugin/**",
     "config/eslint/.peaks-rules.cjs",
+    "config/eslint/tsconfig.lint.json",
     "contracts/test-style-contract.md",
     "README.md",
     "README-en.md",
     "CHANGELOG.md",
     "LICENSE"
   ],
+  "prettier": {
+    "singleQuote": true,
+    "semi": true,
+    "printWidth": 100,
+    "trailingComma": "none",
+    "endOfLine": "lf",
+    "arrowParens": "always",
+    "quoteProps": "as-needed"
+  },
+  "lint-staged": {
+    "*.{ts,tsx,mts,cts,mjs,cjs,js}": [
+      "node .husky/peaks-gate.mjs staged"
+    ]
+  },
   "engines": {
     "node": ">=20.0.0"
   },
@@ -102,10 +117,10 @@
     "picomatch": "4.0.4",
     "yaml": "^2.9.0",
     "zod": "^4.4.3",
-    "peaks-loop-internal-runtime": "0.0.39",
-    "peaks-loop-shared": "0.0.88",
-    "peaks-loop-shared-channel": "0.0.56",
-    "peaks-loop-mut": "0.1.52"
+    "peaks-loop-internal-runtime": "0.0.41",
+    "peaks-loop-mut": "0.1.55",
+    "peaks-loop-shared": "0.0.90",
+    "peaks-loop-shared-channel": "0.0.58"
   },
   "devDependencies": {
     "@changesets/cli": "2.31.1",
@@ -122,19 +137,22 @@
     "@vitest/coverage-v8": "^4.1.10",
     "c8": "^10.1.3",
     "eslint": "8.57.1",
+    "husky": "^9.1.7",
+    "lint-staged": "^15.5.2",
+    "prettier": "^3.9.8",
     "tsx": "^4.19.2",
     "typescript": "^5.7.2",
     "vite": "^6.0.0",
     "vitest": "^4.1.10"
   },
   "scripts": {
-    "build": "node ./scripts/sync-version.mjs && node ./scripts/clean-dist.mjs && pnpm -r --filter \"./packages/*\" run build && tsc -p tsconfig.build.json && node ./scripts/copy-templates.mjs && node ./scripts/check-build-integrity.mjs && node ./scripts/write-dist-stamp.mjs",
+    "build": "node ./scripts/sync-version.mjs && node ./scripts/clean-dist.mjs && pnpm -r --filter \"./packages/*\" run build && node ./scripts/write-package-dist-stamps.mjs && tsc -p tsconfig.build.json && node ./scripts/copy-templates.mjs && node ./scripts/check-build-integrity.mjs && node ./scripts/write-dist-stamp.mjs",
     "prepublish": "node ./scripts/sync-version.mjs",
     "postinstall": "node ./scripts/install-skills.mjs",
     "predev": "node ./scripts/sync-version.mjs",
     "dev": "tsx src/cli/index.ts",
     "dev:watch": "node ./scripts/watch.mjs",
-    "pretest": "node ./scripts/sync-version.mjs && pnpm --filter peaks-loop-shared build && node ./scripts/check-build-integrity.mjs",
+    "pretest": "node ./scripts/sync-version.mjs && pnpm -r --filter \"./packages/*\" run build && node ./scripts/write-package-dist-stamps.mjs && node ./scripts/check-build-integrity.mjs",
     "test": "vitest run",
     "test:full": "pnpm -r --include-workspace-root --workspace-concurrency=2 run test",
     "test:fast": "vitest run --maxWorkers=8 -t \"^((?!@slow|@integration|@replay).)*$\" tests/unit",
@@ -163,6 +181,11 @@
     "mut:run": "peaks mut run --project . --out mut-report.json",
     "mut:scan": "peaks mut asserts --in mut-report.json",
     "audit:prose-ratio": "peaks audit prose-ratio --project .",
-    "dogfood:sediment": "bash scripts/dogfood-sediment-cycle.sh"
+    "dogfood:sediment": "bash scripts/dogfood-sediment-cycle.sh",
+    "lint": "node ./scripts/lint/run-lint.mjs",
+    "format:check": "prettier --check \"src/**/*.{ts,mts,mjs,js}\" \"tests/**/*.{ts,mts,mjs,js}\" \"packages/**/*.{ts,mts,mjs,js}\" \"scripts/**/*.{ts,mts,mjs,js}\"",
+    "format": "prettier --write \"src/**/*.{ts,mts,mjs,js}\" \"tests/**/*.{ts,mts,mjs,js}\" \"packages/**/*.{ts,mts,mjs,js}\" \"scripts/**/*.{ts,mts,mjs,js}\"",
+    "gate:staged": "node .husky/peaks-gate.mjs staged",
+    "gate:repo": "node .husky/peaks-gate.mjs repo"
   }
 }

package/scripts/clean-dist.mjs

@@ -44,7 +44,6 @@ for (const entry of readdirSync(packagesRoot, { withFileTypes: true })) {
   if (!entry.isDirectory()) continue;
   rmSync(join(packagesRoot, entry.name, 'dist'), {
     recursive: true,
-    force: true,
+    force: true
   });
 }
-