@planu/cli 5.3.68 → 5.4.0

package/dist/tools/check-readiness.js

@@ -4,22 +4,64 @@ import { isAbsolute } from 'node:path';
 import { specStore } from '../storage/index.js';
 import { resolveVerifiedSpecPath } from '../storage/project-identity.js';
 import { buildCheckReadinessSummary } from '../engine/human-summary.js';
+// eslint-disable-next-line no-restricted-imports -- grandfathered layer violation, remediation SPEC-1661 SPEC-1662 SPEC-1663
 import { validateSpecFormat } from '../core/spec-validator.js';
 import { parseFrontmatter } from '../engine/frontmatter-parser.js';
 import { resolveProjectId } from './resolve-project-id.js';
 const VALID_DIFFICULTIES = [1, 2, 3, 4, 5];
 const VALID_SCOPES = ['trivial', 'feature', 'cross-module', 'architectural'];
+const VALID_SPEC_TYPES = [
+    'feature',
+    'refactor',
+    'bugfix',
+    'infra',
+    'docs',
+    'project',
+    'agent',
+    'tech-debt',
+];
+const VALID_SPEC_TARGETS = [
+    'frontend',
+    'backend',
+    'shared',
+    'fullstack',
+    'infrastructure',
+    'database',
+    'ios',
+    'android',
+];
 function asDifficulty(value) {
     return VALID_DIFFICULTIES.find((candidate) => candidate === value);
 }
 function asSpecScope(value) {
     return VALID_SCOPES.find((candidate) => candidate === value);
 }
-/**
- * Re-derive difficulty/scope from the freshly-read spec.md frontmatter so the
- * readiness gate honors on-disk edits instead of the specs.json snapshot that
- * `specStore` caches in memory.
- */
+function asSpecType(value) {
+    return VALID_SPEC_TYPES.find((candidate) => candidate === value);
+}
+function asSpecTarget(value) {
+    return VALID_SPEC_TARGETS.find((candidate) => candidate === value);
+}
+function asStringTags(value) {
+    return Array.isArray(value) ? value.filter((tag) => typeof tag === 'string') : [];
+}
+async function synthesizeSpecFromDiscoveredPath(specId, discoveredPath) {
+    const raw = await readFile(discoveredPath, 'utf-8');
+    const { metadata } = parseFrontmatter(raw);
+    return {
+        id: specId,
+        specPath: discoveredPath,
+        difficulty: asDifficulty(metadata.difficulty) ?? 3,
+        tags: asStringTags(metadata.tags),
+        dependencies: [],
+        scope: asSpecScope(metadata.scope) ?? 'feature',
+        target: asSpecTarget(metadata.target) ?? 'backend',
+        type: asSpecType(metadata.type) ?? 'feature',
+        title: typeof metadata.title === 'string' && metadata.title.trim().length > 0
+            ? metadata.title
+            : specId,
+    };
+}
 async function readFreshDifficultyAndScope(specId, specPath, projectPath) {
     try {
         const resolvedPath = projectPath
@@ -43,8 +85,12 @@ async function resolveEffectiveSpecPath(specId, specPath, projectPath) {
     try {
         return await resolveVerifiedSpecPath(specId, specPath, projectPath);
     }
-    catch {
-        return specPath;
+    catch (error) {
+        const discovered = await specStore.discoverCanonicalSpecPath(specId, projectPath);
+        if (discovered === null) {
+            throw error;
+        }
+        return discovered;
     }
 }
 // ── Formatting helpers ───────────────────────────────────────────────────────
@@ -165,30 +211,58 @@ export async function handleCheckReadiness(args) {
     }
     const { specId, mode = 'strict' } = args;
     const spec = await specStore.getSpecFresh(projectId, specId, args.projectPath);
-    if (!spec) {
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `Spec '${specId}' not found in project '${projectId}'`,
-                },
-            ],
-            isError: true,
+    let effectiveSpec;
+    if (spec) {
+        const fresh = spec.specPath
+            ? await readFreshDifficultyAndScope(spec.id, spec.specPath, args.projectPath)
+            : {};
+        let resolvedSpecPath = spec.specPath;
+        if (spec.specPath) {
+            try {
+                resolvedSpecPath = await resolveEffectiveSpecPath(spec.id, spec.specPath, args.projectPath);
+            }
+            catch (error) {
+                const reason = error instanceof Error ? error.message : String(error);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Spec '${specId}' path could not be resolved: ${reason}`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+        }
+        effectiveSpec = {
+            id: spec.id,
+            specPath: resolvedSpecPath,
+            difficulty: fresh.difficulty ?? spec.difficulty,
+            scope: fresh.scope ?? spec.scope,
+            target: spec.target,
+            type: spec.type,
+            title: spec.title,
+            tags: spec.tags,
+            dependencies: spec.dependencies,
         };
     }
-    const fresh = spec.specPath
-        ? await readFreshDifficultyAndScope(spec.id, spec.specPath, args.projectPath)
-        : {};
-    const resolvedSpecPath = spec.specPath
-        ? await resolveEffectiveSpecPath(spec.id, spec.specPath, args.projectPath)
-        : spec.specPath;
-    const effectiveSpec = {
-        ...spec,
-        specPath: resolvedSpecPath,
-        technicalPath: resolvedSpecPath,
-        difficulty: fresh.difficulty ?? spec.difficulty,
-        scope: fresh.scope ?? spec.scope,
-    };
+    else {
+        const discoveredPath = args.projectPath
+            ? await specStore.discoverCanonicalSpecPath(specId, args.projectPath)
+            : null;
+        if (!discoveredPath) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Spec '${specId}' not found in project '${projectId}'`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+        effectiveSpec = await synthesizeSpecFromDiscoveredPath(specId, discoveredPath);
+    }
     // validateSpecFormat owns the readiness and quality evaluation so the response
     // cannot combine separately computed evidence from different reads of spec.md.
     const validationResult = await validateSpecFormat(effectiveSpec, { readinessMode: mode });
@@ -197,7 +271,7 @@ export async function handleCheckReadiness(args) {
     // report — MISSING_FRONTMATTER due to file-not-found is best-effort since
     // the readiness checker already handles missing files gracefully.
     const vr = validationResult;
-    const report = vr.readinessReport ?? createFailClosedReport(spec.id, mode);
+    const report = vr.readinessReport ?? createFailClosedReport(effectiveSpec.id, mode);
     const hardFormatErrors = vr.errors.filter((e) => e.code !== 'MISSING_FRONTMATTER' && !(e.code === 'READINESS_CHECK_FAILED'));
     const hardFormatMessages = hardFormatErrors.map((e) => e.message);
     const formatWarnings = vr.warnings

package/dist/tools/clarify-requirements/multiple-choice.d.ts

@@ -1,6 +1,6 @@
 import type { ClarificationQuestion } from '../../types/index.js';
 /** Detected stack info from package files in the project directory. */
-export interface StackDetectionResult {
+export interface ClarifyStackDetectionResult {
     framework: string | null;
     language: string | null;
     database: string | null;
@@ -11,12 +11,12 @@ export interface StackDetectionResult {
  * Detect the project stack by reading package.json and/or requirements.txt
  * from the given project path.
  */
-export declare function detectStack(projectPath: string): Promise<StackDetectionResult>;
+export declare function detectStack(projectPath: string): Promise<ClarifyStackDetectionResult>;
 /**
  * Returns true if the question should be skipped because the stack already
  * provides a definitive answer.
  */
-export declare function shouldSkipQuestion(question: ClarificationQuestion, stack: StackDetectionResult): boolean;
+export declare function shouldSkipQuestion(question: ClarificationQuestion, stack: ClarifyStackDetectionResult): boolean;
 /**
  * Attaches structured `options[]` to a question based on its content.
  * Each question gets 3-8 concrete choices + 'Other: ___' fallback.

package/dist/tools/configure-oauth-handler.js

@@ -1,5 +1,6 @@
 // configure-oauth-handler.ts — Handler for the configure_oauth MCP tool (SPEC-161).
 // Reads and displays the current OAuth config status (without exposing secrets).
+// eslint-disable-next-line no-restricted-imports -- grandfathered layer violation, remediation SPEC-1661 SPEC-1662 SPEC-1663
 import { loadOAuthConfig, extractBearerToken, validateToken, } from '../transports/oauth-validator.js';
 function buildStatusLines(config) {
     const exampleCurl = config.enabled

package/dist/tools/create-skill.js

@@ -26,14 +26,14 @@ function resolveHost(input) {
 // ---------------------------------------------------------------------------
 // Writers per host
 // ---------------------------------------------------------------------------
-async function writeSkillForClaudeCode(name, content, description, projectPath, overwrite) {
+async function writeSkillForClaudeCode(name, content, description, projectPath, overwrite, managedByPlanu) {
     const dirPath = join(projectPath, '.claude', 'skills', name);
     const skillFilePath = join(dirPath, 'SKILL.md');
     // Overwrite protection
     try {
         const existing = await readFile(skillFilePath, 'utf-8');
         const existingHash = hashContent(existing);
-        const newContent = buildSkillMd(name, description, content);
+        const newContent = buildSkillMd(name, description, content, managedByPlanu);
         const newHash = hashContent(newContent);
         if (existingHash !== newHash && !overwrite) {
             throw new Error(`Skill already exists at ${skillFilePath}. Pass overwriteExisting: true to replace.`);
@@ -46,13 +46,14 @@ async function writeSkillForClaudeCode(name, content, description, projectPath,
         // File doesn't exist — proceed
     }
     await mkdir(dirPath, { recursive: true });
-    const skillContent = buildSkillMd(name, description, content);
+    const skillContent = buildSkillMd(name, description, content, managedByPlanu);
     await writeFile(skillFilePath, skillContent, 'utf-8');
     return { dirPath, skillFilePath };
 }
-function buildSkillMd(name, description, body) {
+function buildSkillMd(name, description, body, managedByPlanu) {
     const desc = description.length > 0 ? description : `Auto-generated skill: ${name}`;
-    return `---\nname: ${name}\ndescription: "${desc}"\n---\n\n${body}\n`;
+    const managedByLine = managedByPlanu ? 'managed-by: planu\n' : '';
+    return `---\nname: ${name}\ndescription: "${desc}"\n${managedByLine}---\n\n${body}\n`;
 }
 async function writeSkillForCodex(name, content, description, projectPath) {
     // For Codex, append to AGENTS.md with markers
@@ -80,13 +81,13 @@ async function writeSkillForCodex(name, content, description, projectPath) {
     await writeFile(agentsMdPath, updated, 'utf-8');
     return { dirPath: projectPath, skillFilePath: agentsMdPath };
 }
-async function writeSkillForGemini(name, content, description, projectPath) {
+async function writeSkillForGemini(name, content, description, projectPath, managedByPlanu) {
     const geminiDir = join(projectPath, '.gemini');
     const skillsDir = join(geminiDir, 'skills');
     await mkdir(skillsDir, { recursive: true });
     const skillFilePath = join(skillsDir, `${name}.md`);
     const desc = description.length > 0 ? description : name;
-    const skillContent = buildSkillMd(name, desc, content);
+    const skillContent = buildSkillMd(name, desc, content, managedByPlanu);
     await writeFile(skillFilePath, skillContent, 'utf-8');
     return { dirPath: skillsDir, skillFilePath };
 }
@@ -96,6 +97,7 @@ async function writeSkillForGemini(name, content, description, projectPath) {
 export async function handleCreateSkill(input) {
     const { projectPath, name, content, overwriteExisting } = input;
     const description = input.description ?? '';
+    const managedByPlanu = input.managedByPlanu === true;
     const host = resolveHost(input);
     const languageValidation = validateEnglishOnlyArtifactText(`${name}\n\n${description}\n\n${content}`, 'skill');
     if (!languageValidation.ok) {
@@ -121,13 +123,13 @@ export async function handleCreateSkill(input) {
     try {
         switch (host) {
             case 'claude-code':
-                result = await writeSkillForClaudeCode(name, content, description, projectPath, overwriteExisting === true);
+                result = await writeSkillForClaudeCode(name, content, description, projectPath, overwriteExisting === true, managedByPlanu);
                 break;
             case 'codex':
                 result = await writeSkillForCodex(name, content, description, projectPath);
                 break;
             case 'gemini':
-                result = await writeSkillForGemini(name, content, description, projectPath);
+                result = await writeSkillForGemini(name, content, description, projectPath, managedByPlanu);
                 break;
         }
     }

package/dist/tools/create-spec-helpers.d.ts

@@ -1,8 +1,6 @@
 import type { GitSetupResult, GitAutoSetupOptions } from '../types/index.js';
+export { generateSpecId } from '../engine/spec-format/spec-id.js';
 export declare function slugify(text: string): string;
-export declare function generateSpecId(existingSpecs: {
-    id: string;
-}[]): string;
 export declare function generateBranchName(specId: string, slug: string, type: string): string;
 /** Try auto-setup git branch. Returns result or undefined on failure. */
 export declare function tryAutoSetupGit(projectId: string, specId: string, options?: GitAutoSetupOptions): Promise<GitSetupResult | undefined>;

package/dist/tools/create-spec-helpers.js

@@ -1,4 +1,5 @@
 import { handleAutoSetup } from './git/branch-ops.js';
+export { generateSpecId } from '../engine/spec-format/spec-id.js';
 export function slugify(text) {
     return text
         .toLowerCase()
@@ -8,14 +9,6 @@ export function slugify(text) {
         .replace(/^-+|-+$/g, '')
         .slice(0, 60);
 }
-export function generateSpecId(existingSpecs) {
-    const maxNum = existingSpecs.reduce((max, spec) => {
-        const match = /^SPEC-(\d+)$/.exec(spec.id);
-        const num = match?.[1] ? parseInt(match[1], 10) : 0;
-        return Math.max(max, num);
-    }, 0);
-    return `SPEC-${String(maxNum + 1).padStart(3, '0')}`;
-}
 const BRANCH_PREFIXES = {
     feature: 'feat',
     refactor: 'refactor',

package/dist/tools/create-spec.js

@@ -6,6 +6,7 @@ import { readTechnologySelectionContract } from '../storage/technology-selection
 import { toolResult, interactiveResult } from './response-helpers.js';
 import { readFile, stat as fsStat } from 'node:fs/promises';
 import { createHash, randomUUID } from 'node:crypto';
+import { pathExistsByStat as pathExists } from '../core/shared/fs.js';
 import { basename as pathBasename, dirname as pathDirname, isAbsolute as pathIsAbsolute, join as pathJoin, relative as pathRelative, sep as pathSeparator, } from 'node:path';
 import { withFileLock } from '../storage/file-mutex.js';
 import { generateBranchName } from './create-spec-helpers.js';
@@ -261,19 +262,6 @@ function isDerivedFromGroundedSource(testPath, modifyFiles) {
         return testPath === `tests/${base}.test${ext}` || testPath === `tests/${withoutSrc}`;
     });
 }
-async function pathExists(path) {
-    try {
-        const fs = await import('node:fs/promises');
-        if (typeof fs.stat !== 'function') {
-            return false;
-        }
-        await fs.stat(path);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
 const HIGH_RISK_WARNING = 'High-risk spec — consider: ' +
     '1) Is the approach technically feasible within the project constraints? ' +
     '2) What edge cases (network failure, concurrent writes, empty state) could break this? ' +

package/dist/tools/dashboard.js

@@ -1,7 +1,12 @@
 // tools/dashboard.ts — MCP tool handlers for start_dashboard and stop_dashboard.
 import { startDashboardWithFallback, stopDashboardServer, registerCleanupHandlers, openBrowser, DEFAULT_DASHBOARD_PORT, } from '../engine/dashboard/server.js';
+import { registerUpdateStatusHandler } from '../engine/dashboard/spec-updater.js';
+import { handleUpdateStatus } from './update-status/index.js';
 // Register process-exit cleanup once at module load time
 registerCleanupHandlers();
+// Wire the tools-layer status gate into the engine's dashboard status route
+// (see engine/dashboard/spec-updater.ts — engine must not import tools/ directly).
+registerUpdateStatusHandler(handleUpdateStatus);
 /** Handle start_dashboard tool invocation */
 export async function handleStartDashboard(args) {
     const port = args.port ?? DEFAULT_DASHBOARD_PORT;

package/dist/tools/github-pr-handler.js

@@ -3,6 +3,7 @@ import { createPlatformClient, getCurrentBranch, getRemoteUrl } from '../engine/
 import { detectAuth } from '../engine/github/auth.js';
 import { generatePRTitle, generatePRBody } from '../engine/github/pr-template.js';
 import { findLinkedPRs } from '../engine/github/spec-linker.js';
+// eslint-disable-next-line no-restricted-imports -- grandfathered layer violation, remediation SPEC-1661 SPEC-1662 SPEC-1663
 import { validateSpecFormat } from '../core/spec-validator.js';
 import { readFile } from 'node:fs/promises';
 import { runAbortableProcess } from '../engine/abortable-process-runner.js';

package/dist/tools/github-release-handler.d.ts

@@ -1,6 +1,7 @@
 import type { ToolResult } from '../types/index.js';
 import type { ExecFileFn } from '../types/github.js';
 import type { EscalateResult } from '../types/escalator.js';
+import './update-status/side-effects.js';
 /**
  * Returns a ToolResult error if stuck specs are detected and no bypass flag
  * is set, or null if release may proceed. Handles autoFixDrift by closing

package/dist/tools/github-release-handler.js

@@ -8,6 +8,8 @@ import { readFile, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { promisify } from 'node:util';
 import { withEscalation } from '../engine/escalator/with-escalation.js';
+// Side-effect import: registers dispatchHookEvent on the cascade hook before runCascade() below.
+import './update-status/side-effects.js';
 const defaultExec = async (cmd, args) => {
     return promisify(nodeExecFile)(cmd, args, { maxBuffer: 10 * 1024 * 1024 });
 };
@@ -127,14 +129,13 @@ export async function handleCreateRelease(args, exec = defaultExec) {
         draft: args.draft,
         prerelease: args.prerelease,
     });
-    // SPEC-496: Regenerate session context on release
     try {
-        const { generateSessionContext } = await import('../engine/session-context-generator.js');
+        const { refreshSessionArtifacts } = await import('../engine/session-state/session-artifact-refresher.js');
         const releasePath = process.cwd();
         const { resolveProjectIdOrAutoDetect } = await import('./resolve-project-id.js');
         const resolved = await resolveProjectIdOrAutoDetect({ projectPath: releasePath });
         if (resolved.ok) {
-            void generateSessionContext(releasePath, resolved.projectId).catch(() => {
+            void refreshSessionArtifacts(releasePath, resolved.projectId).catch(() => {
                 /* best-effort */
             });
         }

package/dist/tools/graph-specs.d.ts

@@ -1,5 +1,5 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { type SpecGraph } from '../engine/spec-dependency-graph/graph-builder.js';
+import type { SpecGraph } from '../types/spec-dependency-graph.js';
 export type GraphSpecsResult = {
     format: 'json';
     graph: SpecGraph;

package/dist/tools/heal-spec-docs.js

@@ -12,6 +12,7 @@ import { jaccard } from '../engine/spec-format/jaccard.js';
 import { replaceSectionInSpec } from '../engine/spec-format/replace-section.js';
 import { executionRemove } from '../engine/execution/deadline-io.js';
 import { buildMigrationDirective, scanLegacyArtifacts, } from '../engine/spec-migrator/legacy-classifier.js';
+import { escapeRegex } from '../core/shared/strings.js';
 const SPANISH_INDICATORS = [
     'de',
     'del',
@@ -112,9 +113,6 @@ function removeTopLevelSection(content, sectionName) {
     }
     return `${before}\n\n${after.trimEnd()}\n`;
 }
-function escapeRegex(input) {
-    return input.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
 /** Local extraction of ## Technical body to avoid circular imports. */
 function extractTechnicalBodyLocal(content) {
     return extractSectionBodyLocal(content, 'Technical') ?? '';

package/dist/tools/init-project/git-setup.d.ts

@@ -1,4 +1,4 @@
-export interface GitSetupResult {
+export interface InitGitSetupResult {
     hooksInstalled: string[];
     gitFlowType: string;
     gitignoreUpdated: boolean;
@@ -7,7 +7,7 @@ export interface GitSetupResult {
 }
 /** SPEC-001 + SPEC-539: Setup git hooks, detect branching model, and configure .gitignore.
  * SPEC-539: Only installs hooks if a git repository is detected — never creates .git. */
-export declare function runGitSetup(projectPath: string, projectId: string): Promise<GitSetupResult>;
+export declare function runGitSetup(projectPath: string, projectId: string): Promise<InitGitSetupResult>;
 /** SPEC-466: Also exported for list_specs auto-cleanup. */
 export declare function configureGitignoreForPlanu(projectPath: string): Promise<boolean>;
 //# sourceMappingURL=git-setup.d.ts.map

package/dist/tools/init-project/host-assets-writer.js

@@ -1,8 +1,9 @@
 // tools/init-project/host-assets-writer.ts — Host-aware rules/skills installed by init_project
-import { access, readFile } from 'node:fs/promises';
+import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { detectHost } from '../../engine/host-detection/detect-host.js';
 import { handleCreateSkill } from '../create-skill.js';
+import { fileExists } from '../../core/shared/fs.js';
 const CORE_SKILL_TEMPLATES = [
     'planu-new-spec.md',
     'planu-validate.md',
@@ -11,16 +12,10 @@ const CORE_SKILL_TEMPLATES = [
     'planu-native.md',
     'planu-multi-teammate-review.md',
     'planu-context-assets.md',
+    'planu-review.md',
+    'planu-implement.md',
+    'planu-dogfood-bug.md',
 ];
-async function fileExists(path) {
-    try {
-        await access(path);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
 function addHost(hosts, host) {
     if (!hosts.includes(host)) {
         hosts.push(host);
@@ -115,6 +110,9 @@ async function canRefreshCoreSkill(projectPath, host, name) {
             return (existing.includes(`<!-- planu:skills:${name} -->`) ||
                 !existing.includes(`## Skill: ${name}`));
         }
+        if (existing.includes('managed-by: planu')) {
+            return true;
+        }
         return existing.includes(`name: ${name}`) && existing.includes(`# /${name}`);
     }
     catch {
@@ -138,6 +136,7 @@ async function installCoreSkillsForHost(projectPath, host) {
             description: template.description,
             content: template.content,
             overwriteExisting: true,
+            managedByPlanu: true,
         });
         if (result.isError === true) {
             continue;

package/dist/tools/init-project/lifecycle-helpers.d.ts

@@ -22,11 +22,11 @@ export declare function generateAndWriteRules(projectPath: string): {
 };
 export declare function fireTelemetry(knowledge: ProjectKnowledge): Promise<boolean>;
 export declare function runConventionScanSafe(projectPath: string): Promise<'ok' | 'failed' | 'skipped'>;
-export interface SkillInstallResult {
+export interface LifecycleSkillInstallResult {
     skillsAutoInstalled: string[];
     skillsPendingInstall: string[];
     skillsSkipped: string[];
 }
 /** Orchestrate skill discovery and installation with autoInstall logic. */
-export declare function orchestrateSkillInstalls(recommendedSkills: RecommendedSkill[], projectPath: string, autoInstallFromConfig: boolean): Promise<SkillInstallResult>;
+export declare function orchestrateSkillInstalls(recommendedSkills: RecommendedSkill[], projectPath: string, autoInstallFromConfig: boolean): Promise<LifecycleSkillInstallResult>;
 //# sourceMappingURL=lifecycle-helpers.d.ts.map

package/dist/tools/init-project/lint-scaffolder.js

@@ -1,5 +1,6 @@
 import { technologyValue } from '../../engine/technology-registry.js';
-import { readFile, writeFile, access } from 'node:fs/promises';
+import { fileExists } from '../../core/shared/fs.js';
+import { readFile, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 const ESLINT_CONFIG_FILES = [
     'eslint.config.js',
@@ -22,15 +23,6 @@ const PRETTIER_CONFIG_FILES = [
     'prettier.config.js',
     'prettier.config.cjs',
 ];
-async function fileExists(filePath) {
-    try {
-        await access(filePath);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
 async function anyFileExists(dir, names) {
     for (const name of names) {
         if (await fileExists(join(dir, name))) {

package/dist/tools/init-project/stack-detector.d.ts

@@ -1,7 +1,7 @@
 import { detectModernPatterns, detectDdd } from '../../engine/architecture-pattern-detector.js';
 import { detectAgileProcess } from '../../engine/agile-config-builder.js';
 import { detectOrchestratorInfo, detectComposeMultiplatform } from './helpers.js';
-export interface StackDetectionResult {
+export interface InitStackDetectionResult {
     modernPatterns: Awaited<ReturnType<typeof detectModernPatterns>>;
     dddConfig: Awaited<ReturnType<typeof detectDdd>>;
     agileDetection: Awaited<ReturnType<typeof detectAgileProcess>>;
@@ -12,5 +12,5 @@ export interface StackDetectionResult {
  * SPEC-033: Detect modern architecture patterns, DDD config, agile process,
  * container orchestrator, and Compose Multiplatform — all in parallel.
  */
-export declare function detectStackPatterns(projectPath: string): Promise<StackDetectionResult>;
+export declare function detectStackPatterns(projectPath: string): Promise<InitStackDetectionResult>;
 //# sourceMappingURL=stack-detector.d.ts.map

package/dist/tools/reconcile-interactive-question-hooks.d.ts

@@ -1,10 +1,10 @@
 import type { ToolResult } from '../types/index.js';
-export interface ReconcileResult {
+export interface HookReconcileResult {
     hookInstalled: boolean;
     settingsUpdated: boolean;
     humanSummary: string;
 }
-export declare function reconcileInteractiveQuestionHooks(projectPath: string): Promise<ReconcileResult>;
+export declare function reconcileInteractiveQuestionHooks(projectPath: string): Promise<HookReconcileResult>;
 export declare function handleReconcileInteractiveQuestionHooks(args: {
     projectPath: string;
 }): Promise<ToolResult>;

package/dist/tools/register-sdd-tools.js

@@ -1,5 +1,6 @@
 // register-sdd-tools.ts — Canonical MCP surface for Planu's SDD workflow.
 import { z } from 'zod';
+// eslint-disable-next-line no-restricted-imports -- grandfathered layer violation, remediation SPEC-1661 SPEC-1662 SPEC-1663
 import { registerResources } from '../resources/registry.js';
 import { registerFromEntries } from './tool-entry.js';
 import coreToolsRegistry from './tool-registry/core-tools.js';

package/dist/tools/safe-handler.js

@@ -31,6 +31,7 @@ import { loadCompactThresholds } from '../engine/compact/registry-loader.js';
 import { applyCompactMode } from '../engine/compact/compact-middleware.js';
 import { globalCompactStateStore } from '../engine/compact/state-store.js';
 import { recordCompactDecision, recordVerboseDecision, recordNoHeader, } from '../engine/compact/metrics.js';
+// eslint-disable-next-line no-restricted-imports -- grandfathered layer violation, remediation SPEC-1661 SPEC-1662 SPEC-1663
 import { getSessionContext } from '../transports/session-context.js';
 import { LocalExecutionSpan } from '../engine/observability/local-execution-spans.js';
 import { classifyBoundaryFailure } from '../errors/error-taxonomy.js';

package/dist/tools/schemas/spec-id.d.ts

@@ -1,7 +1,2 @@
-import { z } from 'zod';
-export declare const SPEC_ID_PATTERN: RegExp;
-export declare const SPEC_DIR_NAME_PATTERN: RegExp;
-export declare const SpecIdSchema: z.ZodString;
-export declare const SpecDirNameSchema: z.ZodString;
-export declare function isCanonicalSpecId(value: string): boolean;
+export { SPEC_ID_PATTERN, SPEC_DIR_NAME_PATTERN, SpecIdSchema, SpecDirNameSchema, isCanonicalSpecId, } from '../../engine/spec-format/spec-id.js';
 //# sourceMappingURL=spec-id.d.ts.map

package/dist/tools/schemas/spec-id.js

@@ -1,17 +1,2 @@
-import { z } from 'zod';
-export const SPEC_ID_PATTERN = /^SPEC-\d+$/;
-export const SPEC_DIR_NAME_PATTERN = /^SPEC-\d+(?:-[a-z0-9]+(?:-[a-z0-9]+)*)?$/;
-export const SpecIdSchema = z
-    .string()
-    .min(1)
-    .max(50)
-    .regex(SPEC_ID_PATTERN, 'Spec ID must use canonical numeric format like SPEC-042.');
-export const SpecDirNameSchema = z
-    .string()
-    .min(1)
-    .max(200)
-    .regex(SPEC_DIR_NAME_PATTERN, 'Spec directory must start with a canonical numeric ID like SPEC-042 or SPEC-042-my-feature.');
-export function isCanonicalSpecId(value) {
-    return SPEC_ID_PATTERN.test(value);
-}
+export { SPEC_ID_PATTERN, SPEC_DIR_NAME_PATTERN, SpecIdSchema, SpecDirNameSchema, isCanonicalSpecId, } from '../../engine/spec-format/spec-id.js';
 //# sourceMappingURL=spec-id.js.map

package/dist/tools/tool-entry.d.ts

@@ -15,7 +15,7 @@ export type ToolInputSchema = Record<string, ZodType>;
  * The `wrap` field controls which safe-handler wrapper is applied by
  * registerFromEntries(). Defaults to 'tracked' when omitted.
  */
-export interface ToolEntry {
+export interface McpToolEntry {
     /** MCP tool name, e.g. 'generate_batch_script'. snake_case. */
     name: string;
     /** Human-readable description surfaced to LLMs. */
@@ -49,5 +49,5 @@ export interface ToolEntry {
  *
  * Drop-in replacement for calling register*Tools(server) on each migrated file.
  */
-export declare function registerFromEntries(server: McpServer, entries: ToolEntry[]): void;
+export declare function registerFromEntries(server: McpServer, entries: McpToolEntry[]): void;
 //# sourceMappingURL=tool-entry.d.ts.map

package/dist/tools/tool-entry.js

@@ -1,4 +1,4 @@
-// tools/tool-entry.ts — Declarative ToolEntry type for registry-based tool registration.
+// tools/tool-entry.ts — Declarative McpToolEntry type for registry-based tool registration.
 //
 // Phase 1 (refactor/declarative-registry): replaces the register-*-tools.ts boilerplate pattern:
 //   server.registerTool(name, { description, inputSchema, annotations }, safeXxx(name, handler))

package/dist/tools/tool-registry/core-tools.d.ts

@@ -1,4 +1,4 @@
-import type { ToolEntry } from '../tool-entry.js';
-declare const coreToolsRegistry: ToolEntry[];
+import type { McpToolEntry } from '../tool-entry.js';
+declare const coreToolsRegistry: McpToolEntry[];
 export default coreToolsRegistry;
 //# sourceMappingURL=core-tools.d.ts.map