@planu/cli 5.3.67 → 5.3.69

package/dist/engine/project-graph/cache.js

@@ -6,6 +6,7 @@ import { open, readdir, readFile, stat } from 'node:fs/promises';
 import { dirname, extname, join, relative, resolve } from 'node:path';
 import { setTimeout as delay } from 'node:timers/promises';
 import { fileURLToPath } from 'node:url';
+// eslint-disable-next-line no-restricted-imports -- grandfathered layer violation, remediation SPEC-1661 SPEC-1662 SPEC-1663
 import { projectDataDir, readJson, writeJson } from '../../storage/base-store.js';
 import { LockBusyError, withSpecLock } from '../safety/cross-process-lock.js';
 const POLICY_PATH = join(dirname(fileURLToPath(import.meta.url)), '../../config/project-knowledge-graph.json');
@@ -23,6 +24,14 @@ const PROJECT_CODE_IGNORED_DIRS = new Set([
 ]);
 const CONTENT_HASH_PATTERN = /^[a-f0-9]{64}$/;
 const PROJECT_GRAPH_LOCK_WAIT_MS = 30_000;
+const OPERATIONAL_SOURCE_KINDS = new Set([
+    'transition-log',
+    'release-events',
+    'decisions',
+    'handoff',
+    'validation',
+]);
+const JSONL_OPERATIONAL_SOURCE_KINDS = new Set(['transition-log', 'release-events']);
 const buildTails = new Map();
 const activeBuilds = new Map();
 export async function loadProjectGraphPolicy() {
@@ -354,14 +363,150 @@ async function readBoundedFile(descriptor, path, maxFileBytes) {
         mtimeMs: info.mtimeMs,
     };
 }
+async function readBoundedFileOrOversized(descriptor, path, maxFileBytes) {
+    try {
+        return await readBoundedFile(descriptor, path, maxFileBytes);
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.startsWith('PROJECT_GRAPH_FILE_TOO_LARGE')) {
+            return null;
+        }
+        throw error;
+    }
+}
+async function readTailChunk(descriptor, size, maxFileBytes) {
+    const start = Math.max(0, size - maxFileBytes);
+    const length = size - start;
+    const buffer = Buffer.allocUnsafe(length);
+    let readTotal = 0;
+    while (readTotal < length) {
+        const { bytesRead } = await descriptor.read(buffer, readTotal, length - readTotal, start + readTotal);
+        if (bytesRead === 0) {
+            break;
+        }
+        readTotal += bytesRead;
+    }
+    const chunk = buffer.subarray(0, readTotal);
+    if (start === 0) {
+        return { chunk, atLineBoundary: true };
+    }
+    const boundaryByte = Buffer.allocUnsafe(1);
+    const { bytesRead: boundaryBytesRead } = await descriptor.read(boundaryByte, 0, 1, start - 1);
+    return {
+        chunk,
+        atLineBoundary: boundaryBytesRead === 1 && boundaryByte[0] === 0x0a,
+    };
+}
+function dropFirstPartialLine(chunk, atLineBoundary) {
+    if (atLineBoundary) {
+        return chunk;
+    }
+    const newlineIndex = chunk.indexOf(0x0a);
+    return newlineIndex === -1 ? Buffer.alloc(0) : chunk.subarray(newlineIndex + 1);
+}
+async function readTailChunkStable(descriptor, maxFileBytes) {
+    const beforeStat = await descriptor.stat();
+    const { chunk, atLineBoundary } = await readTailChunk(descriptor, beforeStat.size, maxFileBytes);
+    const afterStat = await descriptor.stat();
+    return afterStat.size === beforeStat.size
+        ? { chunk, atLineBoundary, mtimeMs: afterStat.mtimeMs }
+        : null;
+}
+async function readBoundedTail(descriptor, maxFileBytes) {
+    const stable = (await readTailChunkStable(descriptor, maxFileBytes)) ??
+        (await readTailChunkStable(descriptor, maxFileBytes));
+    if (stable === null) {
+        return null;
+    }
+    const trimmed = dropFirstPartialLine(stable.chunk, stable.atLineBoundary);
+    if (trimmed.length === 0) {
+        return null;
+    }
+    return {
+        content: trimmed.toString('utf8'),
+        size: trimmed.length,
+        mtimeMs: stable.mtimeMs,
+    };
+}
+async function degradedOperationalSource(args) {
+    const base = {
+        path: args.path,
+        kind: args.kind,
+        bytes: args.bytes,
+        threshold: args.maxFileBytes,
+    };
+    if (!JSONL_OPERATIONAL_SOURCE_KINDS.has(args.kind)) {
+        return { source: null, oversized: { ...base, action: 'skip' } };
+    }
+    const descriptor = await open(args.filePath, 'r');
+    let tail;
+    try {
+        tail = await readBoundedTail(descriptor, args.maxFileBytes);
+    }
+    finally {
+        await descriptor.close();
+    }
+    if (tail === null) {
+        return { source: null, oversized: { ...base, action: 'skip' } };
+    }
+    return {
+        source: {
+            id: args.id,
+            kind: args.kind,
+            path: args.path,
+            content: tail.content,
+            hash: hashText(`${String(args.bytes)}\n${tail.content}`),
+            size: tail.size,
+            mtimeMs: tail.mtimeMs,
+            contentLoaded: true,
+        },
+        oversized: { ...base, action: 'tail' },
+    };
+}
+async function readFreshSource(args) {
+    const descriptor = await open(args.filePath, 'r');
+    let bounded;
+    try {
+        bounded = await readBoundedFileOrOversized(descriptor, args.path, args.maxFileBytes);
+        if (bounded === null && OPERATIONAL_SOURCE_KINDS.has(args.kind)) {
+            bounded = await readBoundedFileOrOversized(descriptor, args.path, args.maxFileBytes);
+        }
+    }
+    finally {
+        await descriptor.close();
+    }
+    if (bounded === null) {
+        if (!OPERATIONAL_SOURCE_KINDS.has(args.kind)) {
+            throw new Error(`PROJECT_GRAPH_FILE_TOO_LARGE: ${args.path} exceeds maxFileBytes (${String(args.maxFileBytes)})`);
+        }
+        const currentBytes = (await stat(args.filePath)).size;
+        return await degradedOperationalSource({ ...args, bytes: currentBytes });
+    }
+    return {
+        source: {
+            id: args.id,
+            kind: args.kind,
+            path: args.path,
+            content: bounded.content,
+            hash: hashText(bounded.content),
+            size: bounded.size,
+            mtimeMs: bounded.mtimeMs,
+            contentLoaded: true,
+        },
+        oversized: null,
+    };
+}
 async function sourceFromFile(args) {
     try {
         const info = await stat(args.filePath);
         if (!info.isFile()) {
-            return null;
+            return { source: null, oversized: null };
         }
         if (info.size > args.maxFileBytes) {
-            throw new Error(`PROJECT_GRAPH_FILE_TOO_LARGE: ${args.path} exceeds maxFileBytes (${String(args.maxFileBytes)})`);
+            if (!OPERATIONAL_SOURCE_KINDS.has(args.kind)) {
+                throw new Error(`PROJECT_GRAPH_FILE_TOO_LARGE: ${args.path} exceeds maxFileBytes (${String(args.maxFileBytes)})`);
+            }
+            return await degradedOperationalSource({ ...args, bytes: info.size });
         }
         const previous = args.previous;
         const expectedNativeVersion = nativeVersionForSource(args.kind, args.nativeCoreVersion);
@@ -375,53 +520,40 @@ async function sourceFromFile(args) {
                 args.nativeCoreVersion === undefined ||
                 previous.nativeCoreVersion === expectedNativeVersion)) {
             return {
-                id: args.id,
-                kind: args.kind,
-                path: args.path,
-                content: '',
-                hash: previous.contentHash,
-                size: info.size,
-                mtimeMs: info.mtimeMs,
-                contentLoaded: false,
+                source: {
+                    id: args.id,
+                    kind: args.kind,
+                    path: args.path,
+                    content: '',
+                    hash: previous.contentHash,
+                    size: info.size,
+                    mtimeMs: info.mtimeMs,
+                    contentLoaded: false,
+                },
+                oversized: null,
             };
         }
-        const descriptor = await open(args.filePath, 'r');
-        let bounded;
-        try {
-            bounded = await readBoundedFile(descriptor, args.path, args.maxFileBytes);
-        }
-        finally {
-            await descriptor.close();
-        }
-        return {
-            id: args.id,
-            kind: args.kind,
-            path: args.path,
-            content: bounded.content,
-            hash: hashText(bounded.content),
-            size: bounded.size,
-            mtimeMs: bounded.mtimeMs,
-            contentLoaded: true,
-        };
+        return await readFreshSource(args);
     }
     catch (error) {
         if (error instanceof Error && error.message.startsWith('PROJECT_GRAPH_')) {
             throw error;
         }
-        return null;
+        return { source: null, oversized: null };
     }
 }
 export async function hydrateProjectGraphSource(source, maxFileBytes) {
     if (source.contentLoaded !== false || source.kind === 'project-code') {
         return source;
     }
-    return sourceFromFile({
+    const result = await sourceFromFile({
         id: source.id,
         kind: source.kind,
         path: source.path,
         filePath: source.path,
         maxFileBytes,
     });
+    return result.source;
 }
 async function collectGitSource(projectPath) {
     try {
@@ -507,18 +639,26 @@ export async function collectProjectGraphSources(args) {
             return { id: `project-code:${path}`, kind: 'project-code', path, filePath };
         }),
     ].sort((a, b) => a.id.localeCompare(b.id));
-    const sources = await Promise.all(raw.map((source) => sourceFromFile({
+    const results = await Promise.all(raw.map((source) => sourceFromFile({
         ...source,
         previous: args.previous?.[source.id],
         nativeCoreVersion: args.nativeCoreVersion,
         maxFileBytes,
     })));
-    const available = sources.filter((source) => source !== null);
+    const available = results
+        .map((result) => result.source)
+        .filter((source) => source !== null);
+    const oversizedSources = results
+        .map((result) => result.oversized)
+        .filter((record) => record !== null);
     const gitSource = await collectGitSource(projectRoot);
     if (gitSource !== null) {
         available.push(gitSource);
     }
-    return available.sort((left, right) => left.id.localeCompare(right.id));
+    return {
+        sources: available.sort((left, right) => left.id.localeCompare(right.id)),
+        oversizedSources,
+    };
 }
 export async function getProjectGraphFreshness(args) {
     const policy = args.policy ?? (await loadProjectGraphPolicy());
@@ -546,7 +686,7 @@ export async function getProjectGraphFreshness(args) {
     }
     const cacheResult = await readProjectGraphCache(args.projectId, policy);
     const previous = cacheResult.cache?.records ?? {};
-    const sources = await collectProjectGraphSources({
+    const { sources } = await collectProjectGraphSources({
         projectId: args.projectId,
         projectPath: args.projectPath,
         policy,

package/dist/engine/project-graph/extractors/decision-store-extractor.js

@@ -1,3 +1,4 @@
+// eslint-disable-next-line no-restricted-imports -- grandfathered layer violation, remediation SPEC-1661 SPEC-1662 SPEC-1663
 import { safeJsonParse } from '../../../storage/base-store.js';
 import { hashText } from '../cache.js';
 import { redactGraphText } from '../redaction.js';

package/dist/engine/project-graph/freshness-projection.js

@@ -1,6 +1,9 @@
 import { join } from 'node:path';
+// eslint-disable-next-line no-restricted-imports -- grandfathered layer violation, remediation SPEC-1661 SPEC-1662 SPEC-1663
 import { projectDataDir } from '../../storage/base-store.js';
+// eslint-disable-next-line no-restricted-imports -- grandfathered layer violation, remediation SPEC-1661 SPEC-1662 SPEC-1663
 import { RuntimeDatabase } from '../../storage/runtime-db.js';
+// eslint-disable-next-line no-restricted-imports -- grandfathered layer violation, remediation SPEC-1661 SPEC-1662 SPEC-1663
 import { resolveStorageLayout } from '../../storage/storage-layout.js';
 const PROJECTION_WORKSPACE = 'project-graph';
 const PROJECTION_KEY = 'freshness-v1';

package/dist/engine/project-graph/query.js

@@ -1,3 +1,4 @@
+// eslint-disable-next-line no-restricted-imports -- grandfathered layer violation, remediation SPEC-1661 SPEC-1662 SPEC-1663
 import { hashProjectPath } from '../../storage/base-store.js';
 import { buildProjectKnowledgeGraph } from './builder.js';
 import { getProjectGraphFreshness, loadProjectGraphPolicy, readProjectGraph } from './cache.js';
@@ -50,27 +51,27 @@ function summarize(nodes) {
         toolHandlers: count('tool_handler'),
     };
 }
+async function ensureFreshProjectGraph(args) {
+    const freshness = await getProjectGraphFreshness(args);
+    if (!freshness.exists ||
+        freshness.reason === 'source_changed' ||
+        freshness.reason === 'corrupt') {
+        await buildProjectKnowledgeGraph(args);
+        return getProjectGraphFreshness(args);
+    }
+    return freshness;
+}
 export async function queryProjectGraphSlice(input) {
     const projectId = input.projectId ?? hashProjectPath(input.projectPath);
     const policy = await loadProjectGraphPolicy();
     if (!policy.enabled) {
         return null;
     }
-    let freshness = await getProjectGraphFreshness({
+    const freshness = await ensureFreshProjectGraph({
         projectId,
         projectPath: input.projectPath,
         policy,
     });
-    if (!freshness.exists ||
-        freshness.reason === 'source_changed' ||
-        freshness.reason === 'corrupt') {
-        await buildProjectKnowledgeGraph({ projectId, projectPath: input.projectPath, policy });
-        freshness = await getProjectGraphFreshness({
-            projectId,
-            projectPath: input.projectPath,
-            policy,
-        });
-    }
     const graph = await readProjectGraph(projectId, policy);
     if (graph === null) {
         return null;
@@ -106,6 +107,8 @@ export async function queryProjectGraphSlice(input) {
         freshness,
         nodes,
         edges,
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- pre-SPEC-1674 persisted artifacts predate this field
+        oversizedSources: graph.oversizedSources ?? [],
         summary: summarize(nodes),
         tokenSavings: {
             compactNodes: nodes.length,

package/dist/engine/project-health-checker.js

@@ -1,17 +1,13 @@
 import { technologyValue } from './technology-registry.js';
+import { fileExists } from '../core/shared/fs.js';
 // @crash-shield-ignore-file — config/cache reader for Planu-controlled JSON; writer is this codebase, shape guaranteed by build/seed.
 // engine/project-health-checker.ts — SPEC-180 + SPEC-192 + SPEC-177: Project health check with convention scanning
 import { execSync } from 'node:child_process';
-import { readFile, access } from 'node:fs/promises';
+import { readFile } from 'node:fs/promises';
 import { join, relative } from 'node:path';
 import { parseConventions, scanConventions } from './convention-scanner/index.js';
 import { fastFindPatterns } from './core-bridge.js';
 // ── helpers ──────────────────────────────────────────────────────────────────
-function fileExists(path) {
-    return access(path)
-        .then(() => true)
-        .catch(() => false);
-}
 function execSafe(cmd, cwd) {
     try {
         return execSync(cmd, { cwd, stdio: ['pipe', 'pipe', 'pipe'] }).toString();

package/dist/engine/provider-adapters/shared/spec-loader.js

@@ -8,6 +8,7 @@
 // (specBody, technicalBody, signatures, scenarios, file lists) and surfaces non-fatal
 // parser issues in `warnings` instead of throwing.
 import { readFile } from 'node:fs/promises';
+// eslint-disable-next-line no-restricted-imports -- grandfathered layer violation, remediation SPEC-1661 SPEC-1662 SPEC-1663
 import { specStore } from '../../../storage/index.js';
 import { stripFrontmatter } from '../../frontmatter-parser.js';
 import { extractSignatures } from './markdown-utils.js';

package/dist/engine/quality-gates/gate-evaluator.js

@@ -1,4 +1,5 @@
 import { GATE_CATALOG } from './gate-catalog.js';
+import { escapeRegex } from '../../core/shared/strings.js';
 export function evaluateGates(specMarkdown) {
     const autoGates = GATE_CATALOG.filter((g) => specMarkdown.includes(`[AUTO] ${g.title}`));
     const passed = autoGates.filter((g) => {
@@ -19,7 +20,4 @@ export function evaluateGates(specMarkdown) {
         score: autoGates.length === 0 ? 100 : Math.round((passed.length / autoGates.length) * 100),
     };
 }
-function escapeRegex(str) {
-    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
 //# sourceMappingURL=gate-evaluator.js.map

package/dist/engine/react-detector.js

@@ -1,18 +1,10 @@
 // Planu — SPEC-051: React 19 + Next.js 16 stack detection
-import { readFile, access } from 'node:fs/promises';
+import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
+import { fileExistsIn } from '../core/shared/fs.js';
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
-async function fileExists(basePath, relativePath) {
-    try {
-        await access(join(basePath, relativePath));
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
 async function readJsonFile(filePath) {
     try {
         const content = await readFile(filePath, 'utf-8');
@@ -98,11 +90,11 @@ async function detectNextjsVersion(projectPath) {
 // Router mode detection
 // ---------------------------------------------------------------------------
 async function detectRouterMode(projectPath) {
-    const hasApp = await fileExists(projectPath, 'app');
-    const hasPages = await fileExists(projectPath, 'pages');
+    const hasApp = await fileExistsIn(projectPath, 'app');
+    const hasPages = await fileExistsIn(projectPath, 'pages');
     // Also check src/ subdirectory (common Next.js project layout)
-    const hasAppSrc = await fileExists(projectPath, 'src/app');
-    const hasPagesSrc = await fileExists(projectPath, 'src/pages');
+    const hasAppSrc = await fileExistsIn(projectPath, 'src/app');
+    const hasPagesSrc = await fileExistsIn(projectPath, 'src/pages');
     const appRouter = hasApp || hasAppSrc;
     const pagesRouter = hasPages || hasPagesSrc;
     if (appRouter && pagesRouter) {

package/dist/engine/reconcile/apply-changes.js

@@ -1,9 +1,7 @@
 import { readFile } from 'node:fs/promises';
 import { atomicWriteFile } from '../safety/atomic-write-file.js';
 import { SECTIONS_WITHOUT_LITERAL_BODY_TEXT, } from '../../types/index.js';
-function escapeRegex(str) {
-    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
+import { escapeRegex } from '../../core/shared/strings.js';
 function findSectionBounds(content, section) {
     const headingRe = new RegExp(`^(#{1,6})\\s+${escapeRegex(section)}\\s*$`, 'mi');
     const match = headingRe.exec(content);

package/dist/engine/registry/core.js

@@ -68,6 +68,7 @@ export { formatReport };
  * Custom entries override base entries with the same framework ID.
  */
 export async function saveCustomEntry(entry) {
+    // eslint-disable-next-line no-restricted-syntax -- grandfathered layer violation, remediation SPEC-1661 SPEC-1662 SPEC-1663
     const { readJson, writeJson, globalDataDir } = await import('../../storage/base-store.js');
     const { join } = await import('node:path');
     const filePath = join(globalDataDir(), 'registry-custom.json');

package/dist/engine/registry/loader.js

@@ -5,7 +5,9 @@
 import { readFile } from 'node:fs/promises';
 import { join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
+// eslint-disable-next-line no-restricted-imports -- grandfathered layer violation, remediation SPEC-1661 SPEC-1662 SPEC-1663
 import { readJson } from '../../storage/base-store.js';
+// eslint-disable-next-line no-restricted-imports -- grandfathered layer violation, remediation SPEC-1661 SPEC-1662 SPEC-1663
 import { resolvedStorageArtifactPath } from '../../storage/storage-catalog.js';
 import { loadTechnologyRegistry } from '../technology-registry.js';
 const REGISTRY_DIR = join(dirname(fileURLToPath(import.meta.url)), '../../config/framework-registry');

package/dist/engine/release/postmortem-generator.js

@@ -1,6 +1,7 @@
 // engine/release/postmortem-generator.ts — SPEC-737: Post-mortem skeleton writer
 import { readFile, writeFile, mkdir } from 'node:fs/promises';
 import { join } from 'node:path';
+// eslint-disable-next-line no-restricted-imports -- grandfathered layer violation, remediation SPEC-1661 SPEC-1662 SPEC-1663
 import { hashProjectPath, projectDataDir } from '../../storage/base-store.js';
 // ---------------------------------------------------------------------------
 // Template path

package/dist/engine/release/rollback-runner.d.ts

@@ -1,5 +1,5 @@
 export type RollbackStepName = 'npm-dist-tag-rm' | 'git-tag-delete-local' | 'git-tag-delete-remote' | 'smoke-test-verify';
-export interface RollbackStep {
+export interface ReleaseRollbackStep {
     name: RollbackStepName;
     status: 'success' | 'failed' | 'skipped';
     stdout?: string;
@@ -14,7 +14,7 @@ export interface RollbackRunnerInput {
 }
 export interface RollbackRunnerResult {
     ok: boolean;
-    steps: RollbackStep[];
+    steps: ReleaseRollbackStep[];
     failedStep?: RollbackStepName;
 }
 /**

package/dist/engine/release/stuck-spec-detector.js

@@ -39,7 +39,9 @@ export async function buildMergedBranchSet(projectPath, targetBranch = 'main') {
  */
 export async function detectStuckSpecs(projectPath, targetBranch = 'main') {
     // Lazy-import storage to keep engine layer free of direct storage coupling
+    // eslint-disable-next-line no-restricted-syntax -- grandfathered layer violation, remediation SPEC-1661 SPEC-1662 SPEC-1663
     const { specStore } = await import('../../storage/index.js');
+    // eslint-disable-next-line no-restricted-syntax -- grandfathered layer violation, remediation SPEC-1661 SPEC-1662 SPEC-1663
     const { hashProjectPath } = await import('../../storage/base-store.js');
     const projectId = hashProjectPath(projectPath);
     const allSpecs = await specStore.listSpecs(projectId);
@@ -73,6 +75,7 @@ export async function detectStuckSpecs(projectPath, targetBranch = 'main') {
  */
 export async function autoCloseStuckSpec(spec, projectPath) {
     try {
+        // eslint-disable-next-line no-restricted-syntax -- grandfathered layer violation, remediation SPEC-1661 SPEC-1662 SPEC-1663
         const { handleUpdateStatus } = await import('../../tools/update-status.js');
         await handleUpdateStatus({
             projectPath,
@@ -89,7 +92,9 @@ export async function autoCloseStuckSpec(spec, projectPath) {
 }
 async function logAutoCloseFailure(specId, projectPath, err) {
     try {
+        // eslint-disable-next-line no-restricted-syntax -- grandfathered layer violation, remediation SPEC-1661 SPEC-1662 SPEC-1663
         const { appendAutopilotLogEntry } = await import('../../storage/autopilot-log-store.js');
+        // eslint-disable-next-line no-restricted-syntax -- grandfathered layer violation, remediation SPEC-1661 SPEC-1662 SPEC-1663
         const { hashProjectPath } = await import('../../storage/base-store.js');
         const projectId = hashProjectPath(projectPath);
         await appendAutopilotLogEntry(projectId, {
@@ -117,7 +122,9 @@ async function logAutoCloseFailure(specId, projectPath, err) {
  */
 export async function logForceReleaseAudit(specIds, projectPath) {
     try {
+        // eslint-disable-next-line no-restricted-syntax -- grandfathered layer violation, remediation SPEC-1661 SPEC-1662 SPEC-1663
         const { appendAutopilotLogEntry } = await import('../../storage/autopilot-log-store.js');
+        // eslint-disable-next-line no-restricted-syntax -- grandfathered layer violation, remediation SPEC-1661 SPEC-1662 SPEC-1663
         const { hashProjectPath } = await import('../../storage/base-store.js');
         const projectId = hashProjectPath(projectPath);
         await appendAutopilotLogEntry(projectId, {

package/dist/engine/release-pipeline/release-spec-closer.js

@@ -6,7 +6,9 @@ import { join } from 'node:path';
 import { promisify } from 'node:util';
 import { atomicWriteFile } from '../safety/atomic-write-file.js';
 import { parseSpecIdsFromCommitMessage } from './parse-spec-refs.js';
+// eslint-disable-next-line no-restricted-imports -- grandfathered layer violation, remediation SPEC-1661 SPEC-1662 SPEC-1663
 import { hashProjectPath } from '../../storage/base-store.js';
+// eslint-disable-next-line no-restricted-imports -- grandfathered layer violation, remediation SPEC-1661 SPEC-1662 SPEC-1663
 import { specStore } from '../../storage/index.js';
 const execFile = promisify(execFileCb);
 const TERMINAL_STATUSES = new Set(['done', 'discarded']);
@@ -139,6 +141,7 @@ async function resolveSpecDir(specsRoot, specId) {
 function logToAutopilot(projectPath, specId, version, success) {
     void (async () => {
         try {
+            // eslint-disable-next-line no-restricted-syntax -- grandfathered layer violation, remediation SPEC-1661 SPEC-1662 SPEC-1663
             const { appendAutopilotLogEntry } = await import('../../storage/autopilot-log-store.js');
             const projectId = hashProjectPath(projectPath);
             await appendAutopilotLogEntry(projectId, {

package/dist/engine/rules-reconciler.d.ts

@@ -1,6 +1,6 @@
 import type { RulesReconciliation } from '../types/index.js';
+import { readFileSafeSync as readFileSafe } from '../core/shared/fs.js';
 export type { RulesReconciliation };
-declare function readFileSafe(path: string): string;
 /**
  * Compare CLAUDE.md conventions against existing .claude/rules/ files.
  * Auto-patches missing convention categories by generating new rules files.

package/dist/engine/rules-reconciler.js

@@ -1,8 +1,9 @@
 // engine/rules-reconciler.ts — Compare CLAUDE.md conventions against .claude/rules/ and auto-patch drift (SPEC-189)
-import { readFileSync, readdirSync, writeFileSync, mkdirSync } from 'node:fs';
+import { readdirSync, writeFileSync, mkdirSync } from 'node:fs';
 import { join, basename } from 'node:path';
 import { parseConventions } from './convention-scanner/convention-parser.js';
 import { assertEnglishOnlyArtifactText } from './spec-language/english-only.js';
+import { readFileSafeSync as readFileSafe } from '../core/shared/fs.js';
 // ── Helpers ───────────────────────────────────────────────────────────────────
 function listRulesFiles(projectPath) {
     const rulesDir = join(projectPath, '.claude', 'rules');
@@ -15,14 +16,6 @@ function listRulesFiles(projectPath) {
         return [];
     }
 }
-function readFileSafe(path) {
-    try {
-        return readFileSync(path, 'utf-8');
-    }
-    catch {
-        return '';
-    }
-}
 /** Unique convention categories detected in CLAUDE.md (source: 'claude-md' only). */
 function categoriesInClaudeMd(rules) {
     const categories = new Set();

package/dist/engine/safety/atomic-writer.js

@@ -3,6 +3,7 @@ import { rename, copyFile, unlink, readFile, writeFile, mkdir } from 'node:fs/pr
 import { existsSync } from 'node:fs';
 import { dirname } from 'node:path';
 import { randomBytes } from 'node:crypto';
+// eslint-disable-next-line no-restricted-imports -- grandfathered layer violation, remediation SPEC-1661 SPEC-1662 SPEC-1663
 import { withFileLock } from '../../storage/file-mutex.js';
 import { reportClassifiedDegradation } from '../../errors/classified-degradation.js';
 const DEFAULT_BACKUP_COUNT = 3;

package/dist/engine/safety/cross-process-lock.js

@@ -55,7 +55,9 @@ import { randomUUID } from 'node:crypto';
 import { hostname as osHostname } from 'node:os';
 import { isAbsolute, join } from 'node:path';
 import { reportClassifiedDegradation } from '../../errors/classified-degradation.js';
+// eslint-disable-next-line no-restricted-imports -- grandfathered layer violation, remediation SPEC-1661 SPEC-1662 SPEC-1663
 import { hashProjectPath } from '../../storage/base-store.js';
+// eslint-disable-next-line no-restricted-imports -- grandfathered layer violation, remediation SPEC-1661 SPEC-1662 SPEC-1663
 import { resolveStorageLayout } from '../../storage/storage-layout.js';
 import { computeStaleReason, isPidDead, STALE_THRESHOLD_MS } from './lock-staleness.js';
 import { LockLeaseStore, } from './lock-lease-store.js';

package/dist/engine/safety/file-mutex.js

@@ -53,6 +53,7 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
 import { createHash, randomUUID } from 'node:crypto';
 import { hostname } from 'node:os';
 import { dirname, join } from 'node:path';
+// eslint-disable-next-line no-restricted-imports -- grandfathered layer violation, remediation SPEC-1661 SPEC-1662 SPEC-1663
 import { resolveStorageLayout } from '../../storage/storage-layout.js';
 import { reportClassifiedDegradation } from '../../errors/classified-degradation.js';
 import { LockLeaseStore } from './lock-lease-store.js';

package/dist/engine/safety/lock-lease-store.js

@@ -1,6 +1,7 @@
 import { chmodSync, existsSync, mkdirSync } from 'node:fs';
 import { dirname, isAbsolute, resolve } from 'node:path';
 import { DatabaseSync } from 'node:sqlite';
+// eslint-disable-next-line no-restricted-imports -- grandfathered layer violation, remediation SPEC-1661 SPEC-1662 SPEC-1663
 import { resolveStorageLayout } from '../../storage/storage-layout.js';
 const SCHEMA_VERSION = 1;
 const DEFAULT_BUSY_TIMEOUT_MS = 5_000;

package/dist/engine/safety/lock-scavenger.js

@@ -53,7 +53,9 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
 import { readFile, readdir, rm } from 'node:fs/promises';
 import { hostname as osHostname } from 'node:os';
 import { isAbsolute, join } from 'node:path';
+// eslint-disable-next-line no-restricted-imports -- grandfathered layer violation, remediation SPEC-1661 SPEC-1662 SPEC-1663
 import { hashProjectPath } from '../../storage/base-store.js';
+// eslint-disable-next-line no-restricted-imports -- grandfathered layer violation, remediation SPEC-1661 SPEC-1662 SPEC-1663
 import { resolveStorageLayout } from '../../storage/storage-layout.js';
 import { reportClassifiedDegradation } from '../../errors/classified-degradation.js';
 import { computeStaleReason, isPidDead } from './lock-staleness.js';