peaks-loop 4.0.54 → 4.1.0

package/dist/services/artifacts/request-artifact-service.js

@@ -92,7 +92,7 @@ export async function createRequestArtifact(options) {
     // canonical session → legacy session). The change-id is preserved
     // in the artifact body's frontmatter (under `- change-id:`) for
     // human navigation; it is no longer a filesystem path key.
-    const sessionId = options.sessionId ?? await ensureSession(options.projectRoot);
+    const sessionId = options.sessionId ?? (await ensureSession(options.projectRoot));
     // Sid axis. The rid axis is guarded three times above (`REQUEST_ID_PATTERN`
     // at :110, and again in the numbered-filename path); the session id was
     // never checked, so `--session-id ../../x` wrote the artifact outside the
@@ -363,7 +363,8 @@ async function readRequestArtifact(dir, role, found, sessionId) {
         const content = await readFile(found.path, 'utf8');
         return { ...summary, content };
     }
-    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;
     }
 }
@@ -374,7 +375,7 @@ async function readRequestArtifact(dir, role, found, sessionId) {
 // the sibling `request-artifact-state-helpers.ts` module — see
 // v2.18.3 file-split for the rationale. Function signatures and
 // behaviour are unchanged (verbatim move).
-import { ALLOWED_STATES_PER_ROLE, FileSizeViolationError, LintGateError, PrerequisitesNotSatisfiedError, readArtifactState, TypeSanityViolationError, updateStatusBlock, } from './request-artifact-state-helpers.js';
+import { ALLOWED_STATES_PER_ROLE, FileSizeViolationError, LintGateError, PrerequisitesNotSatisfiedError, readArtifactState, TypeSanityViolationError, updateStatusBlock } from './request-artifact-state-helpers.js';
 export { allowedStatesForRole, FileSizeViolationError, LintGateError, PrerequisitesNotSatisfiedError, TypeSanityViolationError, updateStatusBlock } from './request-artifact-state-helpers.js';
 export async function transitionRequestArtifact(options) {
     if (!VALID_ROLES.has(options.role)) {
@@ -423,7 +424,9 @@ export async function transitionRequestArtifact(options) {
     // immutable peaks-prd handoff (sha256-frontmatter) for the same intent;
     // see PRD for `v2-11-rd-techdoc-removal-and-runtime-friction` AC-3/AC-4.)
     // Type sanity check for PRD handoff
-    if (options.typeSanityCheck !== undefined && options.role === 'prd' && options.newState === 'handed-off') {
+    if (options.typeSanityCheck !== undefined &&
+        options.role === 'prd' &&
+        options.newState === 'handed-off') {
         const sanityReport = checkTypeSanity({
             projectRoot: options.typeSanityCheck.projectRoot,
             declaredType: options.typeSanityCheck.declaredType
@@ -448,10 +451,12 @@ export async function transitionRequestArtifact(options) {
         }
     }
     // File size gate: when RD declares implemented, scan for oversized files (karpathy-skills "Simplicity First")
-    if (options.role === 'rd' && options.newState === 'implemented' && options.allowIncomplete !== true) {
+    if (options.role === 'rd' &&
+        options.newState === 'implemented' &&
+        options.allowIncomplete !== true) {
         const sizeResult = scanFileSize({ projectRoot: options.projectRoot });
         if (!sizeResult.ok) {
-            throw new FileSizeViolationError(sizeResult.violations, sizeResult.threshold);
+            throw new FileSizeViolationError(sizeResult.violations);
         }
     }
     const clock = options.clock ?? defaultClock;
@@ -459,7 +464,9 @@ export async function transitionRequestArtifact(options) {
     const bypassNote = !prerequisiteResult.ok && options.allowIncomplete === true
         ? `bypassed prerequisites (${prerequisiteResult.missing.map((entry) => entry.path).join(', ')})`
         : undefined;
-    const combinedReason = [options.reason, bypassNote].filter((part) => part !== undefined && part.length > 0).join(' | ');
+    const combinedReason = [options.reason, bypassNote]
+        .filter((part) => part !== undefined && part.length > 0)
+        .join(' | ');
     const reasonForNote = combinedReason.length > 0 ? combinedReason : undefined;
     const { updated, previousState } = updateStatusBlock(existing.content, options.newState, timestamp, reasonForNote);
     await writeFile(existing.path, updated, 'utf8');

package/dist/services/artifacts/request-artifact-state-helpers.d.ts

@@ -38,12 +38,13 @@ export declare class FileSizeViolationError extends Error {
     readonly violations: Array<{
         file: string;
         lines: number;
+        cap: number;
     }>;
-    readonly threshold: number;
     constructor(violations: Array<{
         file: string;
         lines: number;
-    }>, threshold: number);
+        cap: number;
+    }>);
 }
 export interface ArtifactStateLocation {
     /** Index of the authoritative `- state:` line, or -1 when the document has none. */

package/dist/services/artifacts/request-artifact-state-helpers.js

@@ -64,15 +64,13 @@ export class TypeSanityViolationError extends Error {
 export class FileSizeViolationError extends Error {
     code = 'FILE_SIZE_VIOLATION';
     violations;
-    threshold;
-    constructor(violations, threshold) {
-        const summary = violations.map((v) => `${v.file} (${v.lines} lines)`).join(', ');
-        super(`File size violation: ${violations.length} file(s) exceed ${threshold} lines: ${summary}. ` +
+    constructor(violations) {
+        const summary = violations.map((v) => `${v.file} (${v.lines} lines, cap ${v.cap})`).join(', ');
+        super(`File size violation: ${violations.length} file(s) exceed their file-size cap: ${summary}. ` +
             'Split into smaller modules, or consider reusing existing components / existing API data ' +
             '(karpathy-guidelines §2 Simplicity First), or use --allow-incomplete to bypass.');
         this.name = 'FileSizeViolationError';
         this.violations = violations;
-        this.threshold = threshold;
     }
 }
 /**

package/dist/services/artifacts/workspace-artifact-helpers.d.ts

@@ -0,0 +1,28 @@
+import type { WorkspaceConfig } from '../config/config-types.js';
+export type SyncStatus = 'synced' | 'pending' | 'out-of-sync' | 'unknown';
+export type ArtifactWorkspaceStatus = {
+    workspaceId: string;
+    localPath: string;
+    configured: boolean;
+    syncStatus: SyncStatus;
+    lastSync: string | null;
+    hasLocalChanges: boolean;
+    artifactRepo: WorkspaceConfig['artifactRepo'] | null;
+    nextActions: string[];
+};
+export type SyncResult = {
+    workspaceId: string;
+    success: boolean;
+    localPath: string;
+    remoteUrl: string | null;
+    commands: string[];
+    output: string[];
+    error?: string;
+};
+export declare function canonicalPath(path: string): string;
+export declare function canonicalChildPath(parentPath: string, ...segments: string[]): string;
+export declare function getLocalArtifactPath(workspace: WorkspaceConfig): string;
+export declare function getArtifactRemoteRepo(workspace: WorkspaceConfig): WorkspaceConfig['artifactRepo'] | null;
+export declare function getPublicRemoteUrl(artifactRepo: WorkspaceConfig['artifactRepo'] | null): string | null;
+export declare function getGitAuthEnv(artifactRepo: WorkspaceConfig['artifactRepo'] | null): NodeJS.ProcessEnv | undefined;
+export declare function redactSecrets(message: string): string;

package/dist/services/artifacts/workspace-artifact-helpers.js

@@ -0,0 +1,54 @@
+import { Buffer } from 'node:buffer';
+import { resolve } from 'node:path';
+import { stablePath } from '../../shared/path-utils.js';
+export function canonicalPath(path) {
+    return stablePath(path);
+}
+export function canonicalChildPath(parentPath, ...segments) {
+    return stablePath(resolve(parentPath, ...segments));
+}
+export function getLocalArtifactPath(workspace) {
+    if (workspace.artifactStorage?.localPath) {
+        return resolve(workspace.artifactStorage.localPath);
+    }
+    return resolve(workspace.rootPath, '.peaks', 'artifacts');
+}
+export function getArtifactRemoteRepo(workspace) {
+    if (workspace.artifactStorage?.mode === 'local-with-remote-sync') {
+        return workspace.artifactStorage.remote;
+    }
+    if (workspace.artifactStorage?.mode === 'local') {
+        return null;
+    }
+    return workspace.artifactRepo ?? null;
+}
+export function getPublicRemoteUrl(artifactRepo) {
+    if (!artifactRepo)
+        return null;
+    return artifactRepo.provider === 'github'
+        ? `https://github.com/${artifactRepo.owner}/${artifactRepo.name}.git`
+        : `https://gitlab.com/${artifactRepo.owner}/${artifactRepo.name}.git`;
+}
+export function getGitAuthEnv(artifactRepo) {
+    if (!artifactRepo || artifactRepo.provider !== 'github')
+        return undefined;
+    const token = process.env.GH_TOKEN;
+    if (!token)
+        return undefined;
+    const authValue = Buffer.from(`x-access-token:${token}`, 'utf-8').toString('base64');
+    return {
+        ...process.env,
+        GIT_CONFIG_COUNT: '1',
+        GIT_CONFIG_KEY_0: 'http.https://github.com/.extraheader',
+        GIT_CONFIG_VALUE_0: `AUTHORIZATION: basic ${authValue}`
+    };
+}
+export function redactSecrets(message) {
+    const token = process.env.GH_TOKEN;
+    const urlRedacted = message.replace(/https:\/\/x-access-token:[^@]+@/g, 'https://x-access-token:***@');
+    const headerRedacted = urlRedacted.replace(/AUTHORIZATION:\s*basic\s+[A-Za-z0-9+/=]+/gi, 'AUTHORIZATION: basic ***');
+    if (!token)
+        return headerRedacted;
+    const encoded = Buffer.from(`x-access-token:${token}`, 'utf-8').toString('base64');
+    return headerRedacted.replaceAll(token, '***').replaceAll(encoded, '***');
+}

package/dist/services/artifacts/workspace-service.d.ts

@@ -1,28 +1,9 @@
 import type { WorkspaceConfig } from '../config/config-types.js';
-export type SyncStatus = 'synced' | 'pending' | 'out-of-sync' | 'unknown';
-export type ArtifactWorkspaceStatus = {
-    workspaceId: string;
-    localPath: string;
-    configured: boolean;
-    syncStatus: SyncStatus;
-    lastSync: string | null;
-    hasLocalChanges: boolean;
-    artifactRepo: WorkspaceConfig['artifactRepo'] | null;
-    nextActions: string[];
-};
-export type SyncResult = {
-    workspaceId: string;
-    success: boolean;
-    localPath: string;
-    remoteUrl: string | null;
-    commands: string[];
-    output: string[];
-    error?: string;
-};
-export declare function getLocalArtifactPath(workspace: WorkspaceConfig): string;
+import { getArtifactRemoteRepo, getLocalArtifactPath, type ArtifactWorkspaceStatus, type SyncResult, type SyncStatus } from './workspace-artifact-helpers.js';
+export { getArtifactRemoteRepo, getLocalArtifactPath };
+export type { ArtifactWorkspaceStatus, SyncResult, SyncStatus };
 export declare function isArtifactWorkspaceOutsideTarget(_workspace: WorkspaceConfig, _artifactWorkspacePath?: string): boolean;
 export declare function hasValidArtifactWorkspace(workspace: WorkspaceConfig, artifactWorkspacePath?: string): boolean;
-export declare function getArtifactRemoteRepo(workspace: WorkspaceConfig): WorkspaceConfig['artifactRepo'] | null;
 export declare function executeArtifactSync(workspaceId?: string): Promise<SyncResult>;
 export declare function getArtifactWorkspaceStatus(workspaceId?: string): ArtifactWorkspaceStatus;
 export declare function planArtifactSync(workspaceId?: string, dryRun?: boolean): {

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

@@ -1,22 +1,11 @@
 import { existsSync } from 'node:fs';
-import { Buffer } from 'node:buffer';
 import { resolve } from 'node:path';
-import { isInsidePath, stablePath } from '../../shared/path-utils.js';
+import { isInsidePath } from '../../shared/path-utils.js';
 import { getWorkspaceConfig, getWorkspaceConfigForCurrentPath } from '../config/config-service.js';
 import { pathExists } from 'peaks-loop-shared/fs';
 import { execCommand } from '../../shared/process.js';
-function canonicalPath(path) {
-    return stablePath(path);
-}
-function canonicalChildPath(parentPath, ...segments) {
-    return stablePath(resolve(parentPath, ...segments));
-}
-export function getLocalArtifactPath(workspace) {
-    if (workspace.artifactStorage?.localPath) {
-        return resolve(workspace.artifactStorage.localPath);
-    }
-    return resolve(workspace.rootPath, '.peaks', 'artifacts');
-}
+import { canonicalChildPath, canonicalPath, getArtifactRemoteRepo, getGitAuthEnv, getLocalArtifactPath, getPublicRemoteUrl, redactSecrets } from './workspace-artifact-helpers.js';
+export { getArtifactRemoteRepo, getLocalArtifactPath };
 export function isArtifactWorkspaceOutsideTarget(_workspace, _artifactWorkspacePath) {
     return true;
 }
@@ -37,45 +26,6 @@ export function hasValidArtifactWorkspace(workspace, artifactWorkspacePath = get
         return false;
     return true;
 }
-export function getArtifactRemoteRepo(workspace) {
-    if (workspace.artifactStorage?.mode === 'local-with-remote-sync') {
-        return workspace.artifactStorage.remote;
-    }
-    if (workspace.artifactStorage?.mode === 'local') {
-        return null;
-    }
-    return workspace.artifactRepo ?? null;
-}
-function getPublicRemoteUrl(artifactRepo) {
-    if (!artifactRepo)
-        return null;
-    return artifactRepo.provider === 'github'
-        ? `https://github.com/${artifactRepo.owner}/${artifactRepo.name}.git`
-        : `https://gitlab.com/${artifactRepo.owner}/${artifactRepo.name}.git`;
-}
-function getGitAuthEnv(artifactRepo) {
-    if (!artifactRepo || artifactRepo.provider !== 'github')
-        return undefined;
-    const token = process.env.GH_TOKEN;
-    if (!token)
-        return undefined;
-    const authValue = Buffer.from(`x-access-token:${token}`, 'utf-8').toString('base64');
-    return {
-        ...process.env,
-        GIT_CONFIG_COUNT: '1',
-        GIT_CONFIG_KEY_0: 'http.https://github.com/.extraheader',
-        GIT_CONFIG_VALUE_0: `AUTHORIZATION: basic ${authValue}`
-    };
-}
-function redactSecrets(message) {
-    const token = process.env.GH_TOKEN;
-    const urlRedacted = message.replace(/https:\/\/x-access-token:[^@]+@/g, 'https://x-access-token:***@');
-    const headerRedacted = urlRedacted.replace(/AUTHORIZATION:\s*basic\s+[A-Za-z0-9+/=]+/gi, 'AUTHORIZATION: basic ***');
-    if (!token)
-        return headerRedacted;
-    const encoded = Buffer.from(`x-access-token:${token}`, 'utf-8').toString('base64');
-    return headerRedacted.replaceAll(token, '***').replaceAll(encoded, '***');
-}
 export async function executeArtifactSync(workspaceId) {
     const workspace = workspaceId
         ? getWorkspaceConfig(workspaceId)
@@ -191,18 +141,16 @@ export function getArtifactWorkspaceStatus(workspaceId) {
             lastSync: null,
             hasLocalChanges: false,
             artifactRepo: null,
-            nextActions: ['Add a workspace with: peaks config workspace add --id <id> --name <name> --path <path>']
+            nextActions: [
+                'Add a workspace with: peaks config workspace add --id <id> --name <name> --path <path>'
+            ]
         };
     }
     const localPath = getLocalArtifactPath(workspace);
     const hasLocalDir = existsSync(localPath);
     const artifactRepo = getArtifactRemoteRepo(workspace);
     const hasSafeBoundary = isArtifactWorkspaceOutsideTarget(workspace, localPath);
-    const syncStatus = !hasSafeBoundary
-        ? 'unknown'
-        : !hasLocalDir
-            ? 'pending'
-            : 'synced';
+    const syncStatus = !hasSafeBoundary ? 'unknown' : !hasLocalDir ? 'pending' : 'synced';
     return {
         workspaceId: workspace.workspaceId,
         localPath,
@@ -228,7 +176,9 @@ export function planArtifactSync(workspaceId, dryRun = true) {
             dryRun,
             localPath: '.peaks-artifacts',
             remoteUrl: null,
-            plannedCommands: ['No artifact repo configured — add one with peaks config workspace add --provider github --repo-owner <owner> --repo-name <name>']
+            plannedCommands: [
+                'No artifact repo configured — add one with peaks config workspace add --provider github --repo-owner <owner> --repo-name <name>'
+            ]
         };
     }
     const localPath = getLocalArtifactPath(workspace);

package/dist/services/audit/artifact-writer.js

@@ -103,13 +103,13 @@ const KIND_TO_SUBDIR = {
     decision: 'audit-decisions',
     prompt: 'audit-prompts',
     'machine-output': null, // top-level (no subdir)
-    narrative: null, // top-level (no subdir)
+    narrative: null // top-level (no subdir)
 };
 const KIND_TO_SLUG_PREFIX = {
     decision: 'audit-decision',
     prompt: 'audit-prompt',
     'machine-output': 'audit-output',
-    narrative: 'audit-narrative',
+    narrative: 'audit-narrative'
 };
 function resolvePath(args) {
     const memoryDir = join(args.projectRoot, '.peaks', 'memory');
@@ -117,7 +117,7 @@ function resolvePath(args) {
     const targetDir = subdir === null ? memoryDir : join(memoryDir, subdir);
     return {
         memoryDir,
-        filePath: join(targetDir, `${args.slug}.md`),
+        filePath: join(targetDir, `${args.slug}.md`)
     };
 }
 // ---------------------------------------------------------------------------
@@ -130,14 +130,14 @@ export function writeDecision(audit, options) {
         projectRoot: options.projectRoot,
         kind: 'decision',
         slug,
-        date,
+        date
     });
     const description = `Audit Decision ${date}${options.rid ? ` (${options.rid})` : ''}`;
     const renderOpts = options.rid ? { date, rid: options.rid } : { date };
     const markdown = renderDecisionMarkdown(audit, renderOpts);
     if (!options.dryRun) {
         mkdirSync(join(options.projectRoot, '.peaks', 'memory', KIND_TO_SUBDIR.decision ?? ''), {
-            recursive: true,
+            recursive: true
         });
         writeFileSync(filePath, markdown, { mode: 0o644 });
     }
@@ -151,7 +151,7 @@ export function writeDecision(audit, options) {
         filePath,
         memoryDir,
         indexPath,
-        indexSynced: index !== null,
+        indexSynced: index !== null
     };
 }
 export function writePrompt(input, options) {
@@ -161,7 +161,7 @@ export function writePrompt(input, options) {
         projectRoot: options.projectRoot,
         kind: 'prompt',
         slug,
-        date,
+        date
     });
     const frontmatter = buildFrontmatter({
         name: slug,
@@ -170,13 +170,13 @@ export function writePrompt(input, options) {
         extras: {
             sourceArtifact: 'peaks audit artifact write --kind prompt',
             createdAt: date,
-            artifactType: 'prompt',
-        },
+            artifactType: 'prompt'
+        }
     });
     const markdown = `${frontmatter}\n\n# ${input.name}\n\n${input.body}\n`;
     if (!options.dryRun) {
         mkdirSync(join(options.projectRoot, '.peaks', 'memory', KIND_TO_SUBDIR.prompt ?? ''), {
-            recursive: true,
+            recursive: true
         });
         writeFileSync(filePath, markdown, { mode: 0o644 });
     }
@@ -190,7 +190,7 @@ export function writePrompt(input, options) {
         filePath,
         memoryDir,
         indexPath,
-        indexSynced: index !== null,
+        indexSynced: index !== null
     };
 }
 export function writeMachineOutput(input, options) {
@@ -200,7 +200,7 @@ export function writeMachineOutput(input, options) {
         projectRoot: options.projectRoot,
         kind: 'machine-output',
         slug,
-        date,
+        date
     });
     const rawJson = readInputContent(input.json);
     // Validate that it's at least JSON-parseable; if not, fail loud.
@@ -217,8 +217,8 @@ export function writeMachineOutput(input, options) {
         extras: {
             sourceArtifact: 'peaks audit artifact write --kind machine-output',
             createdAt: date,
-            artifactType: 'machine-output',
-        },
+            artifactType: 'machine-output'
+        }
     });
     const title = input.name;
     const summaryTable = [
@@ -226,7 +226,7 @@ export function writeMachineOutput(input, options) {
         '| --- | --- |',
         `| Artifact kind | machine-output |`,
         `| JSON bytes | ${rawJson.length} |`,
-        `| Captured at | ${date} |`,
+        `| Captured at | ${date} |`
     ].join('\n');
     const body = [
         `# ${title}`,
@@ -242,7 +242,7 @@ export function writeMachineOutput(input, options) {
         '```json',
         rawJson,
         '```',
-        '',
+        ''
     ].join('\n');
     const markdown = `${frontmatter}\n\n${body}`;
     if (!options.dryRun) {
@@ -260,7 +260,7 @@ export function writeMachineOutput(input, options) {
         filePath,
         memoryDir,
         indexPath,
-        indexSynced: index !== null,
+        indexSynced: index !== null
     };
 }
 export function writeNarrative(input, options) {
@@ -270,7 +270,7 @@ export function writeNarrative(input, options) {
         projectRoot: options.projectRoot,
         kind: 'narrative',
         slug,
-        date,
+        date
     });
     const frontmatter = buildFrontmatter({
         name: slug,
@@ -279,8 +279,8 @@ export function writeNarrative(input, options) {
         extras: {
             sourceArtifact: 'peaks audit artifact write --kind narrative',
             createdAt: date,
-            artifactType: 'narrative',
-        },
+            artifactType: 'narrative'
+        }
     });
     const markdown = `${frontmatter}\n\n# ${input.name}\n\n${input.body}\n`;
     if (!options.dryRun) {
@@ -298,6 +298,6 @@ export function writeNarrative(input, options) {
         filePath,
         memoryDir,
         indexPath,
-        indexSynced: index !== null,
+        indexSynced: index !== null
     };
 }

package/dist/services/audit/audit-goal-service.js

@@ -74,8 +74,8 @@ export async function auditGoal(input, llmRunner) {
     if (!isAuditGoalOutput(parsed)) {
         throw new IncompleteAuditError('LLM output is missing required top-level fields (summary, audit, proposedGoal, successCriteria, roughEffort, confidence, rationale).');
     }
-    const presentDimensions = new Set(parsed.audit.map(d => d.dimension));
-    const missing = REQUIRED_DIMENSIONS.filter(d => !presentDimensions.has(d));
+    const presentDimensions = new Set(parsed.audit.map((d) => d.dimension));
+    const missing = REQUIRED_DIMENSIONS.filter((d) => !presentDimensions.has(d));
     if (missing.length > 0) {
         throw new IncompleteAuditError(`Missing required audit dimensions: ${missing.join(', ')}`);
     }

package/dist/services/audit/backing-detector.js

@@ -22,7 +22,7 @@ const PARTIAL_PHRASES = [
     'best effort',
     'advisory only',
     'soft enforcement',
-    'when remembered',
+    'when remembered'
 ];
 function detectPartial(context) {
     const lower = context.toLowerCase();
@@ -37,12 +37,15 @@ function detectPartial(context) {
 export function classifyBacking(entry, projectRoot, liveEnforcers) {
     const enforcerPath = entry.enforcerRef === null ? null : resolve(projectRoot, entry.enforcerRef);
     const exists = enforcerPath !== null && existsSync(enforcerPath);
-    const dead = entry.enforcerRef !== null && exists && liveEnforcers !== null && !liveEnforcers.has(entry.enforcerRef);
+    const dead = entry.enforcerRef !== null &&
+        exists &&
+        liveEnforcers !== null &&
+        !liveEnforcers.has(entry.enforcerRef);
     if (detectPartial(entry.source.context)) {
         return {
             entry: { ...entry, backing: 'partial' },
             enforcerExists: exists,
-            enforcerDead: dead,
+            enforcerDead: dead
         };
     }
     if (entry.enforcerRef === null) {
@@ -52,7 +55,7 @@ export function classifyBacking(entry, projectRoot, liveEnforcers) {
     return {
         entry: { ...entry, backing: backed ? 'cli-backed' : 'prose-only' },
         enforcerExists: exists,
-        enforcerDead: dead,
+        enforcerDead: dead
     };
 }
 export function classifyBackingBatch(entries, projectRoot, liveEnforcers) {

package/dist/services/audit/classifier.js

@@ -88,7 +88,7 @@ export function classifyFile(input) {
             file: input.file,
             line: idx + 1,
             marker,
-            context,
+            context
         };
         if (catalog) {
             entries.push({
@@ -96,7 +96,7 @@ export function classifyFile(input) {
                 rule: catalog.rule,
                 source,
                 backing: catalog.enforcerRef === null ? 'prose-only' : 'cli-backed',
-                enforcerRef: catalog.enforcerRef,
+                enforcerRef: catalog.enforcerRef
             });
         }
         else {
@@ -113,7 +113,7 @@ export function classifyFile(input) {
                 source,
                 backing: 'prose-only',
                 enforcerRef: null,
-                informational: true,
+                informational: true
             });
         }
     }

package/dist/services/audit/decision-writer.js

@@ -87,6 +87,18 @@ function severityCounts(findings) {
     }
     return { fail, warn, pass };
 }
+function buildSummaryTable(audit, sev) {
+    const summaryTable = [
+        '| Metric | Count |',
+        '| --- | --- |',
+        `| Total red lines | ${audit.totalRedLines} |`,
+        `| CLI-backed | ${audit.cliBacked} |`,
+        `| Partial | ${audit.partial} |`,
+        `| Prose-only | ${audit.proseOnly} |`,
+        `| Enforcer findings (pass / warn / fail) | ${sev.pass} / ${sev.warn} / ${sev.fail} |`
+    ].join('\n');
+    return summaryTable;
+}
 /**
  * Pure: render the decision markdown body. No I/O. Used by both the
  * writer and the test suite for byte-exact assertions.
@@ -116,15 +128,7 @@ export function renderDecisionMarkdown(audit, options) {
         `  createdAt: ${date}`,
         '---'
     ].join('\n');
-    const summaryTable = [
-        '| Metric | Count |',
-        '| --- | --- |',
-        `| Total red lines | ${audit.totalRedLines} |`,
-        `| CLI-backed | ${audit.cliBacked} |`,
-        `| Partial | ${audit.partial} |`,
-        `| Prose-only | ${audit.proseOnly} |`,
-        `| Enforcer findings (pass / warn / fail) | ${sev.pass} / ${sev.warn} / ${sev.fail} |`
-    ].join('\n');
+    const summaryTable = buildSummaryTable(audit, sev);
     const ruleSection = renderPerRuleSection(audit);
     const enforcerSection = renderEnforcerSection(audit.enforcerFindings);
     const body = [

package/dist/services/audit/enforcers/active-skill-resolver.js

@@ -97,7 +97,9 @@ export function resolveActiveSkillForCaller(projectRoot, opts) {
         // caller's lease. Slice 2026-08-04-rid-005 surfaces this for the
         // statusline read so two concurrent sessions bound to the same
         // project session do not see each other's skill.
-        if (typeof opts?.callerId === 'string' && opts.callerId.length > 0 && lease.callerId !== opts.callerId)
+        if (typeof opts?.callerId === 'string' &&
+            opts.callerId.length > 0 &&
+            lease.callerId !== opts.callerId)
             continue;
         try {
             const projection = readPresenceLease({
@@ -105,19 +107,23 @@ export function resolveActiveSkillForCaller(projectRoot, opts) {
                 sessionId,
                 callerId: lease.callerId,
                 workflowId: lease.workflowId,
-                graphRef: lease.graphRef,
+                graphRef: lease.graphRef
             });
-            if (projection.lease !== null && typeof projection.lease.skill === 'string' && projection.lease.skill.length > 0) {
+            if (projection.lease !== null &&
+                typeof projection.lease.skill === 'string' &&
+                projection.lease.skill.length > 0) {
                 return {
                     skill: projection.lease.skill,
                     callerId: lease.callerId,
                     sessionId,
                     mode: normalizeSkillPresenceMode(typeof projection.mode === 'string' ? projection.mode : null) ?? null,
-                    source: 'canonical',
+                    source: 'canonical'
                 };
             }
         }
-        catch { /* fall through to next lease */ }
+        catch {
+            /* fall through to next lease */
+        }
     }
     // Legacy fall-back (one minor release). Gated on `legacyPresence:
     // true` so production hooks prefer the canonical projection. Reads
@@ -140,11 +146,13 @@ export function resolveActiveSkillForCaller(projectRoot, opts) {
                 const raw = readFileSync(filePath, 'utf8');
                 const parsed = JSON.parse(raw);
                 if (typeof parsed.skill === 'string' && parsed.skill.length > 0) {
-                    const legacyMode = normalizeSkillPresenceMode(typeof parsed.mode === 'string' ? parsed.mode : null) ?? null;
+                    const legacyMode = normalizeSkillPresenceMode(typeof parsed.mode === 'string' ? parsed.mode : null) ??
+                        null;
                     return { skill: parsed.skill, callerId, sessionId, mode: legacyMode, source: 'file' };
                 }
             }
-            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)
                 // skip malformed file
             }
         }