peaks-loop 4.0.54 → 4.1.1

package/dist/services/workspace/reconcile-service.js

@@ -215,9 +215,7 @@ export function findDeletionCandidates(entries, ageThresholdMs) {
         const isEmptyOrAutoOnly = e.artifactCount === 0;
         if (!isEmptyOrAutoOnly)
             continue;
-        const mtime = e.lastActivity !== null
-            ? e.lastActivity
-            : readDirMtime(e.path);
+        const mtime = e.lastActivity !== null ? e.lastActivity : readDirMtime(e.path);
         if (mtime === null)
             continue;
         if (now - mtime < ageThresholdMs)
@@ -230,7 +228,8 @@ function readDirMtime(dirPath) {
     try {
         return statSync(dirPath).mtimeMs;
     }
-    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;
     }
 }
@@ -288,7 +287,8 @@ function readActiveSkillSessionId(projectRoot) {
             return parsed.sessionId;
         }
     }
-    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;
     }
     return null;
@@ -421,7 +421,11 @@ export function reconcileWorkspace(options) {
     // of the apply flag — syncing the marker is a derived-state write,
     // not a destructive side effect.
     const changeMarker = canonical === null
-        ? { removed: [], created: null, error: 'no canonical session' }
+        ? {
+            removed: [],
+            created: null,
+            error: 'no canonical session'
+        }
         : syncChangeMarker(projectRoot, canonical.sessionId);
     // Slice 006: clean up the F3-introduced `.peaks/_runtime/<sid>/system/`
     // subdir under EVERY session dir (not just the canonical one). The
@@ -439,7 +443,8 @@ export function reconcileWorkspace(options) {
                 rmSync(systemDir, { recursive: true, force: true });
                 systemCleaned.push(systemDir);
             }
-            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)
                 // Best-effort: a locked subdir does not block the rest of reconcile.
             }
         }
@@ -495,11 +500,19 @@ export function reconcilePresenceLeases(input) {
             const raw = readFileSync(newPath, 'utf8');
             const parsed = JSON.parse(raw);
             if (typeof parsed?.skill !== 'string') {
-                conflicts.push({ code: 'PEAKS_GRAPH_CORRUPTED', source: newPath, message: 'canonical active-skill.json malformed' });
+                conflicts.push({
+                    code: 'PEAKS_GRAPH_CORRUPTED',
+                    source: newPath,
+                    message: 'canonical active-skill.json malformed'
+                });
             }
         }
         catch (err) {
-            conflicts.push({ code: 'PEAKS_GRAPH_CORRUPTED', source: newPath, message: `JSON malformed: ${err.message}` });
+            conflicts.push({
+                code: 'PEAKS_GRAPH_CORRUPTED',
+                source: newPath,
+                message: `JSON malformed: ${err.message}`
+            });
         }
     }
     // Legacy sources (per-caller markers + the singleton).
@@ -515,7 +528,9 @@ export function reconcilePresenceLeases(input) {
             const receipt = JSON.parse(readFileSync(receiptPath, 'utf8'));
             migratedCount = typeof receipt.migratedCount === 'number' ? receipt.migratedCount : 0;
         }
-        catch { /* swallow; treat as empty receipt */ }
+        catch {
+            /* swallow; treat as empty receipt */
+        }
     }
     // Migration itself: copy each legacy source into the canonical tree.
     if (!existsSync(sessionRoot))
@@ -543,7 +558,7 @@ export function reconcilePresenceLeases(input) {
             legacyPresence: false,
             migratedCount,
             createdCount: 0,
-            receiptPath: null,
+            receiptPath: null
         };
     }
     for (const legacy of legacyPaths) {
@@ -562,7 +577,7 @@ export function reconcilePresenceLeases(input) {
                 startedAt: new Date().toISOString(),
                 lastHeartbeat: new Date().toISOString(),
                 status: 'preparing',
-                schemaVersion: 1,
+                schemaVersion: 1
             };
             const leasePath = join(leasesDir, `presence-${caller}-${workflowId}.json`);
             const tmpPath = `${leasePath}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
@@ -572,7 +587,11 @@ export function reconcilePresenceLeases(input) {
             migratedCount += 1;
         }
         catch (err) {
-            conflicts.push({ code: 'PEAKS_LEASE_IO_FAILED', source: legacy, message: err.message });
+            conflicts.push({
+                code: 'PEAKS_LEASE_IO_FAILED',
+                source: legacy,
+                message: err.message
+            });
         }
     }
     if (createdCount > 0) {
@@ -580,18 +599,20 @@ export function reconcilePresenceLeases(input) {
             schemaVersion: 1,
             migratedCount,
             sources: legacyPaths,
-            ts: new Date().toISOString(),
+            ts: new Date().toISOString()
         };
         try {
             writeFileSync(receiptPath, JSON.stringify(receipt, null, 2), 'utf8');
         }
-        catch { /* best-effort */ }
+        catch {
+            /* best-effort */
+        }
     }
     return {
         conflicts,
         legacyPresence: legacyPaths.length > 0,
         migratedCount,
         createdCount,
-        receiptPath: createdCount > 0 ? receiptPath : null,
+        receiptPath: createdCount > 0 ? receiptPath : null
     };
 }

package/dist/services/workspace/workspace-claude-settings-materializer.js

@@ -42,7 +42,9 @@ function readSettingsObject(serialized) {
 /** The `env` object of a serialized settings file, or `undefined`. */
 function readEnvObject(serialized) {
     const env = readSettingsObject(serialized)?.env;
-    return typeof env === 'object' && env !== null && !Array.isArray(env) ? env : undefined;
+    return typeof env === 'object' && env !== null && !Array.isArray(env)
+        ? env
+        : undefined;
 }
 /**
  * The top-level keys this function's template is allowed to DECIDE. Every other
@@ -156,8 +158,8 @@ const PEAKS_GITIGNORE_SNIPPET = [
     '.claude/settings.local.json',
     '# Offline template copy (.peaks/.claude-settings-template.json): written by',
     '# `peaks workspace init` as a manual-recovery anchor. The source-of-truth is',
-    '# peaks-loop\'s own `buildClaudeSettingsLocalJson()` — NOT this committed copy.',
-    '# Gitignored so the init flow\'s drift-driven refresh does not show up as',
+    "# peaks-loop's own `buildClaudeSettingsLocalJson()` — NOT this committed copy.",
+    "# Gitignored so the init flow's drift-driven refresh does not show up as",
     '# "modified" in `git status` on every release bump. Recovery path: re-run',
     '# `peaks workspace init` to regenerate; or copy from peaks-loop source.',
     '# Both patterns below are PROJECT-ROOT-relative, so this snippet must land',
@@ -167,13 +169,13 @@ const PEAKS_GITIGNORE_SNIPPET = [
     '# `repair-exclude` / `repair-index` / pre-dispatch preflight / post-slice',
     '# auto-refresh copies `.codegraph/config.json` here before rewriting it, so',
     '# this file is LOCAL CHURN: a committed one is silently replaced by the next',
-    '# repair. Upstream\'s own `.codegraph/.gitignore` does not cover it (it names',
+    "# repair. Upstream's own `.codegraph/.gitignore` does not cover it (it names",
     '# *.db / *.db-wal / *.db-shm, cache/, *.log and .dirty only) and `.codegraph/`',
     '# is NOT ignored wholesale downstream, so without this line a consumer project',
     '# commits a file peaks-loop rewrites under it.',
     '#',
     '# ONLY the backup, never `config.json` itself: upstream deliberately keeps',
-    '# that config committable (it is a project\'s include/exclude policy, and',
+    "# that config committable (it is a project's include/exclude policy, and",
     '# committing it is how a team shares it), so ignoring it would hide a file',
     '# people mean to commit. A rollback copy is the opposite kind of file.',
     '.codegraph/config.json.bak',

package/dist/services/workspace/workspace-clean-service.js

@@ -28,7 +28,10 @@ export function planRuntimeCleanup(sessions, options) {
             eligible.push(s.sid);
         }
         else {
-            skipped.push({ sid: s.sid, reason: `fresh: age=${s.ageHours.toFixed(1)}h < cutoff=${cutoffHours}h` });
+            skipped.push({
+                sid: s.sid,
+                reason: `fresh: age=${s.ageHours.toFixed(1)}h < cutoff=${cutoffHours}h`
+            });
         }
     }
     return { eligible, skipped };

package/dist/services/workspace/workspace-service.js

@@ -24,7 +24,8 @@ function rebindCurrentCallerBinding(projectRoot, sessionId) {
     try {
         callerId = resolveCallerProjection({ projectRoot, env: process.env }).callerId;
     }
-    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 false;
     }
     return updateCallerBindingSessionId(projectRoot, callerId, sessionId);
@@ -85,7 +86,14 @@ function isDateStampedSiblingId(name) {
 import { detectMissingProjectStandards } from '../standards/missing-standards-detector.js';
 import { detectLanguage, executeProjectStandardsInit } from '../standards/project-standards-service.js';
 const SESSION_ID_PATTERN = /^\d{4}-\d{2}-\d{2}-[a-z][a-z0-9-]*[a-z0-9]$/;
-const PROHIBITED_SUFFIXES = ['session', 'work', 'task', 'test', 'temp', 'tmp'];
+const PROHIBITED_SUFFIXES = [
+    'session',
+    'work',
+    'task',
+    'test',
+    'temp',
+    'tmp'
+];
 // Auto-generated session ID pattern: YYYY-MM-DD-session-<6位hex>
 const AUTO_SESSION_PATTERN = /^\d{4}-\d{2}-\d{2}-session-[a-f0-9]{6}$/;
 /**
@@ -186,7 +194,7 @@ export async function initWorkspace(options) {
     // is `$HOME`) resolved to `$HOME` and did exactly that — `.peaks/`,
     // `.gitignore`, `.claude/settings.local.json` and a codegraph index, all in
     // the user's home. Enforced here as well as at the CLI so a non-CLI caller
-    // (`peaks upgrade`) cannot reach the same write by another door.
+    // cannot reach the same write by another door.
     assertWritableProjectRoot(options.projectRoot);
     // Phase 6 refactor (slice 2026-06-05-change-id-as-unit-of-work) +
     // slice 006 (2026-06-06-change-folder-simplify-and-lazy-role-subdirs) +
@@ -319,7 +327,7 @@ export async function initWorkspace(options) {
         // Refuse to rebind without explicit authorization.
         previousSessionId = existingSessionId;
         const existingSessionDir = join(runtimeRoot, existingSessionId);
-        if (await isDirectory(existingSessionDir) && !options.allowSessionRebind) {
+        if ((await isDirectory(existingSessionDir)) && !options.allowSessionRebind) {
             const { readdirSync } = await import('node:fs');
             const entries = readdirSync(existingSessionDir);
             if (entries.length > 0) {

package/dist/services/workspace/workspace-state-service.js

@@ -11,7 +11,7 @@ import { join, posix } from 'node:path';
  */
 const LEGACY_DOTFILES = [
     '.peaks-init-hooks-decision.json',
-    '.peaks-openspec-opt-in.json',
+    '.peaks-openspec-opt-in.json'
 ];
 const STATE_DIR_NAME = '_state';
 export function isLegacyDecisionDotfile(name) {

package/dist/services/worktree/git-worktree-parser.js

@@ -8,7 +8,7 @@ export function parseGitWorktreePorcelain(raw) {
                 path: current.path,
                 head: current.head,
                 branch: current.branch,
-                prunable: current.prunable,
+                prunable: current.prunable
             });
         }
         current = null;
@@ -27,10 +27,20 @@ export function parseGitWorktreePorcelain(raw) {
             current = next;
         }
         else if (current !== null && key === 'HEAD') {
-            current = { path: current.path, head: value, branch: current.branch, prunable: current.prunable };
+            current = {
+                path: current.path,
+                head: value,
+                branch: current.branch,
+                prunable: current.prunable
+            };
         }
         else if (current !== null && key === 'branch') {
-            current = { path: current.path, head: current.head, branch: value.replace(/^refs\/heads\//, ''), prunable: current.prunable };
+            current = {
+                path: current.path,
+                head: current.head,
+                branch: value.replace(/^refs\/heads\//, ''),
+                prunable: current.prunable
+            };
         }
         else if (current !== null && key === 'prunable') {
             current = { path: current.path, head: current.head, branch: current.branch, prunable: true };

package/dist/services/worktree/host-worktree-reconciler.js

@@ -11,7 +11,7 @@ export function reconcileHostWorktrees(input) {
             cwd: input.projectRoot,
             encoding: 'utf8',
             stdio: ['ignore', 'pipe', 'pipe'],
-            windowsHide: true,
+            windowsHide: true
         });
         records = parseGitWorktreePorcelain(raw);
     }
@@ -22,7 +22,7 @@ export function reconcileHostWorktrees(input) {
     const leaseResult = listLeasesSync(storeDir, {
         existsSync,
         readdir: (path) => readdirSync(path),
-        readFile: (path) => readFileSync(path, 'utf8'),
+        readFile: (path) => readFileSync(path, 'utf8')
     });
     const leases = leaseResult.kind === 'ok' ? leaseResult.leases : [];
     const leaseByPath = new Map(leases.map((lease) => [resolve(lease.path), lease.leaseId]));
@@ -33,8 +33,12 @@ export function reconcileHostWorktrees(input) {
         return {
             ...record,
             managedLeaseId,
-            state: record.prunable ? 'prunable' : managedLeaseId === null ? 'unleased' : 'managed',
+            state: record.prunable ? 'prunable' : managedLeaseId === null ? 'unleased' : 'managed'
         };
     });
-    return { hostRoot, findings, unmanaged: findings.filter((finding) => finding.state !== 'managed') };
+    return {
+        hostRoot,
+        findings,
+        unmanaged: findings.filter((finding) => finding.state !== 'managed')
+    };
 }

package/dist/services/worktree/long-path-cleanup.js

@@ -14,25 +14,42 @@ export function removeRegisteredWorktree(input) {
         execFileSync('git', ['worktree', 'remove', '--force', input.worktreePath], {
             cwd: input.projectRoot,
             stdio: ['ignore', 'pipe', 'pipe'],
-            windowsHide: true,
+            windowsHide: true
+        });
+        execFileSync('git', ['worktree', 'prune'], {
+            cwd: input.projectRoot,
+            stdio: 'ignore',
+            windowsHide: true
         });
-        execFileSync('git', ['worktree', 'prune'], { cwd: input.projectRoot, stdio: 'ignore', windowsHide: true });
         return { removed: !existsSync(input.worktreePath), strategy: 'git' };
     }
     catch (error) {
         if (process.platform !== 'win32') {
-            return { removed: false, strategy: 'none', error: error instanceof Error ? error.message : String(error) };
+            return {
+                removed: false,
+                strategy: 'none',
+                error: error instanceof Error ? error.message : String(error)
+            };
         }
         try {
-            rmSync(windowsLongPath(input.worktreePath), { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
-            execFileSync('git', ['worktree', 'prune'], { cwd: input.projectRoot, stdio: 'ignore', windowsHide: true });
+            rmSync(windowsLongPath(input.worktreePath), {
+                recursive: true,
+                force: true,
+                maxRetries: 3,
+                retryDelay: 100
+            });
+            execFileSync('git', ['worktree', 'prune'], {
+                cwd: input.projectRoot,
+                stdio: 'ignore',
+                windowsHide: true
+            });
             return { removed: !existsSync(input.worktreePath), strategy: 'windows-long-path' };
         }
         catch (fallbackError) {
             return {
                 removed: false,
                 strategy: 'none',
-                error: fallbackError instanceof Error ? fallbackError.message : String(fallbackError),
+                error: fallbackError instanceof Error ? fallbackError.message : String(fallbackError)
             };
         }
     }

package/dist/services/worktree/worktree-gc-guard.js

@@ -34,5 +34,7 @@ export function findManagedSkillJunctionReferences(input) {
 function isInside(parent, candidate) {
     const normalizedParent = resolve(parent).toLowerCase();
     const normalizedCandidate = resolve(candidate).toLowerCase();
-    return normalizedCandidate === normalizedParent || normalizedCandidate.startsWith(`${normalizedParent}\\`) || normalizedCandidate.startsWith(`${normalizedParent}/`);
+    return (normalizedCandidate === normalizedParent ||
+        normalizedCandidate.startsWith(`${normalizedParent}\\`) ||
+        normalizedCandidate.startsWith(`${normalizedParent}/`));
 }

package/dist/services/worktree/worktree-lease-types.d.ts

@@ -0,0 +1,53 @@
+/**
+ * worktree-lease-types — the pure declaration surface of the worktree lease
+ * store (`worktree-lease.ts`).
+ *
+ * Slice 2026-07-29-worktree-l2-extended Part 1 owns the lease behavior; this
+ * module owns only the shapes (lifecycle status, lease record, creation draft,
+ * and the list-read result). `worktree-lease.ts` imports and re-exports every
+ * name here, so importers keep resolving them from the original path.
+ */
+export type WorktreeLeaseStatus = 'active' | 'released' | 'expired' | 'gc';
+export interface WorktreeLease {
+    /** Random 16-hex lease id; emitted to the operator as the lease handle. */
+    readonly leaseId: string;
+    /** The peaks request id (rid) that the lease was spawned for. */
+    readonly rid: string;
+    /** Sub-agent role (rd | qa | ui | sc | prd | general-purpose | ...). */
+    readonly role: string;
+    /** Absolute worktree path on disk (under .peaks/_runtime/<sid>/worktrees/<leaseId>/). */
+    readonly path: string;
+    /** Branch name (one of the worktree's --branch / -b args). */
+    readonly branch: string;
+    /** Unix epoch ms when the lease was created. */
+    readonly createdAt: number;
+    /** Unix epoch ms when the lease expires. */
+    readonly expiresAt: number;
+    /** Operator-supplied purpose text (audit log). */
+    readonly purpose: string;
+    /** Lifecycle status; updated by `releaseLease` / `markExpired`. */
+    readonly status: WorktreeLeaseStatus;
+    /** Sub-agent batch / dispatch ids that have consumed this lease. */
+    readonly consumedBySubAgents: ReadonlyArray<string>;
+}
+/** Subset of WorktreeLease that the CLI writes on creation. Status starts at 'active'. */
+export type WorktreeLeaseDraft = Omit<WorktreeLease, 'status' | 'consumedBySubAgents'>;
+/**
+ * Pure: read every lease file under the session's lease store dir.
+ * Returns leases in the order returned by `fs.readdir` (no sort).
+ * Malformed files are surfaced as `{ file, error }` records so the caller
+ * (the `list` CLI) can warn without aborting the whole list. Missing
+ * directory is not an error — it returns an empty leases array.
+ */
+export interface LeaseReadError {
+    readonly file: string;
+    readonly error: string;
+}
+export type LeaseListResult = {
+    readonly kind: 'ok';
+    readonly leases: ReadonlyArray<WorktreeLease>;
+    readonly errors: ReadonlyArray<LeaseReadError>;
+} | {
+    readonly kind: 'store-missing';
+    readonly storeDir: string;
+};

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

@@ -0,0 +1,10 @@
+/**
+ * worktree-lease-types — the pure declaration surface of the worktree lease
+ * store (`worktree-lease.ts`).
+ *
+ * Slice 2026-07-29-worktree-l2-extended Part 1 owns the lease behavior; this
+ * module owns only the shapes (lifecycle status, lease record, creation draft,
+ * and the list-read result). `worktree-lease.ts` imports and re-exports every
+ * name here, so importers keep resolving them from the original path.
+ */
+export {};

package/dist/services/worktree/worktree-lease.d.ts

@@ -24,33 +24,10 @@
  * implicitly authorizes worktree operations on its path (the hook
  * integration is Part 2 of this slice).
  */
+import type { LeaseListResult, WorktreeLease, WorktreeLeaseDraft } from './worktree-lease-types.js';
+export type { LeaseListResult, LeaseReadError, WorktreeLease, WorktreeLeaseDraft, WorktreeLeaseStatus } from './worktree-lease-types.js';
 export declare const DEFAULT_TTL_BY_ROLE: Readonly<Record<string, number>>;
 export declare const DEFAULT_TTL_MS: number | undefined;
-export type WorktreeLeaseStatus = 'active' | 'released' | 'expired' | 'gc';
-export interface WorktreeLease {
-    /** Random 16-hex lease id; emitted to the operator as the lease handle. */
-    readonly leaseId: string;
-    /** The peaks request id (rid) that the lease was spawned for. */
-    readonly rid: string;
-    /** Sub-agent role (rd | qa | ui | sc | prd | general-purpose | ...). */
-    readonly role: string;
-    /** Absolute worktree path on disk (under .peaks/_runtime/<sid>/worktrees/<leaseId>/). */
-    readonly path: string;
-    /** Branch name (one of the worktree's --branch / -b args). */
-    readonly branch: string;
-    /** Unix epoch ms when the lease was created. */
-    readonly createdAt: number;
-    /** Unix epoch ms when the lease expires. */
-    readonly expiresAt: number;
-    /** Operator-supplied purpose text (audit log). */
-    readonly purpose: string;
-    /** Lifecycle status; updated by `releaseLease` / `markExpired`. */
-    readonly status: WorktreeLeaseStatus;
-    /** Sub-agent batch / dispatch ids that have consumed this lease. */
-    readonly consumedBySubAgents: ReadonlyArray<string>;
-}
-/** Subset of WorktreeLease that the CLI writes on creation. Status starts at 'active'. */
-export type WorktreeLeaseDraft = Omit<WorktreeLease, 'status' | 'consumedBySubAgents'>;
 /**
  * Compose a deterministic lease path under the per-session runtime dir.
  * The function is pure: same inputs → same output. The caller passes
@@ -102,25 +79,6 @@ export declare function recordConsumption(lease: WorktreeLease, subAgentId: stri
  * but `isLeaseActive` returns false so consumers skip the lease.
  */
 export declare function isLeaseActive(lease: WorktreeLease, now?: number): boolean;
-/**
- * Pure: read every lease file under the session's lease store dir.
- * Returns leases in the order returned by `fs.readdir` (no sort).
- * Malformed files are surfaced as `{ file, error }` records so the caller
- * (the `list` CLI) can warn without aborting the whole list. Missing
- * directory is not an error — it returns an empty leases array.
- */
-export interface LeaseReadError {
-    readonly file: string;
-    readonly error: string;
-}
-export type LeaseListResult = {
-    readonly kind: 'ok';
-    readonly leases: ReadonlyArray<WorktreeLease>;
-    readonly errors: ReadonlyArray<LeaseReadError>;
-} | {
-    readonly kind: 'store-missing';
-    readonly storeDir: string;
-};
 /**
  * List every lease file under the session's lease store dir.
  *

package/dist/shared/array-guards.d.ts

@@ -0,0 +1,30 @@
+/**
+ * `Array.isArray` written so that it does NOT narrow.
+ *
+ * WHY THIS EXISTS (S10, 2026-09-20). TypeScript declares `Array.isArray` as
+ * `(arg: any) => arg is any[]`. That is right for an `unknown` argument and
+ * WRONG for an already-typed one: applied to a `readonly SliceNode[]`, the
+ * guard narrows the value to `any[]`, so every later element access
+ * (`n.id`, `e.from`, …) is an `any` access. `@typescript-eslint/no-unsafe-*`
+ * then reports the widening, not the caller's intent — and the guard was
+ * measuring "is this an array at runtime?", which it still does below.
+ *
+ * Measured effect of the widening at the S10 census: 107 of the 817 TS
+ * `no-unsafe-*` findings across 7 files (slice-dag, workflow-graph-store,
+ * workflow-inflight-probe, spec-service, contract-store, eslint-runner,
+ * api-diff-openapi). Those files hold values that are ALREADY correctly typed;
+ * `Array.isArray` was the only thing discarding the type.
+ *
+ * Returning plain `boolean` is the honest shape here: it reports the runtime
+ * fact and asserts nothing about the type. A predicate like
+ * `value is readonly T[]` would silence the same findings with an unchecked
+ * assertion — the same offence as a cast — which this slice is explicitly
+ * forbidden from adding.
+ *
+ * Consequence at call sites: after `if (!isArray(x)) throw`, TypeScript does
+ * NOT know `x` is defined, because a `boolean` return cannot narrow. A site
+ * that also needs defined-ness must say so — write
+ * `if (x === undefined || !isArray(x)) throw`, which is what the call sites
+ * below do. That is the price of not asserting, and it is paid in the open.
+ */
+export declare function isArray(value: unknown): boolean;

package/dist/shared/array-guards.js

@@ -0,0 +1,32 @@
+/**
+ * `Array.isArray` written so that it does NOT narrow.
+ *
+ * WHY THIS EXISTS (S10, 2026-09-20). TypeScript declares `Array.isArray` as
+ * `(arg: any) => arg is any[]`. That is right for an `unknown` argument and
+ * WRONG for an already-typed one: applied to a `readonly SliceNode[]`, the
+ * guard narrows the value to `any[]`, so every later element access
+ * (`n.id`, `e.from`, …) is an `any` access. `@typescript-eslint/no-unsafe-*`
+ * then reports the widening, not the caller's intent — and the guard was
+ * measuring "is this an array at runtime?", which it still does below.
+ *
+ * Measured effect of the widening at the S10 census: 107 of the 817 TS
+ * `no-unsafe-*` findings across 7 files (slice-dag, workflow-graph-store,
+ * workflow-inflight-probe, spec-service, contract-store, eslint-runner,
+ * api-diff-openapi). Those files hold values that are ALREADY correctly typed;
+ * `Array.isArray` was the only thing discarding the type.
+ *
+ * Returning plain `boolean` is the honest shape here: it reports the runtime
+ * fact and asserts nothing about the type. A predicate like
+ * `value is readonly T[]` would silence the same findings with an unchecked
+ * assertion — the same offence as a cast — which this slice is explicitly
+ * forbidden from adding.
+ *
+ * Consequence at call sites: after `if (!isArray(x)) throw`, TypeScript does
+ * NOT know `x` is defined, because a `boolean` return cannot narrow. A site
+ * that also needs defined-ness must say so — write
+ * `if (x === undefined || !isArray(x)) throw`, which is what the call sites
+ * below do. That is the price of not asserting, and it is paid in the open.
+ */
+export function isArray(value) {
+    return Array.isArray(value);
+}

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

@@ -0,0 +1,26 @@
+/**
+ * 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 declare const FENCE_MARKER_RE: RegExp;
+export declare const TABLE_ROW_RE: RegExp;
+export declare const TABLE_ALIGN_ROW_RE: RegExp;
+export declare const ATX_HEADING_RE: RegExp;
+export declare const HEADING_LINE_RE: RegExp;
+export declare const SETEXT_UNDERLINE_RE: RegExp;
+export interface ParsedFrontmatter {
+    raw: string;
+    description: string | null;
+    body: string;
+}
+export declare function splitFrontmatter(input: string): ParsedFrontmatter;
+export declare function isFenceOpenLine(line: string): boolean;
+export declare function isFenceCloseLine(line: string, insideFence: boolean): boolean;
+export declare function isTableLine(line: string): boolean;
+export declare function computeSetextUnderlines(lines: string[]): Set<number>;
+export declare function isDecorativeHorizontalRule(line: string): boolean;
+export declare function collapseMultiBlanks(lines: string[]): string[];