@planu/cli 5.3.67 → 5.3.69

package/dist/tools/check-readiness.js

@@ -1,26 +1,73 @@
 // tools/check-readiness.ts — Completeness checkpoint tool (SPEC-039, SPEC-314, SPEC-716)
 import { readFile } from 'node:fs/promises';
+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.
- */
-async function readFreshDifficultyAndScope(specPath) {
+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 raw = await readFile(specPath, 'utf-8');
+        const resolvedPath = projectPath
+            ? await resolveVerifiedSpecPath(specId, specPath, projectPath)
+            : specPath;
+        const raw = await readFile(resolvedPath, 'utf-8');
         const { metadata } = parseFrontmatter(raw);
         return {
             difficulty: asDifficulty(metadata.difficulty),
@@ -31,6 +78,21 @@ async function readFreshDifficultyAndScope(specPath) {
         return {};
     }
 }
+async function resolveEffectiveSpecPath(specId, specPath, projectPath) {
+    if (!projectPath || isAbsolute(specPath)) {
+        return specPath;
+    }
+    try {
+        return await resolveVerifiedSpecPath(specId, specPath, projectPath);
+    }
+    catch (error) {
+        const discovered = await specStore.discoverCanonicalSpecPath(specId, projectPath);
+        if (discovered === null) {
+            throw error;
+        }
+        return discovered;
+    }
+}
 // ── Formatting helpers ───────────────────────────────────────────────────────
 const MAX_VISIBLE_BLOCKERS = 8;
 const MAX_VISIBLE_WARNINGS = 8;
@@ -148,24 +210,59 @@ export async function handleCheckReadiness(args) {
         };
     }
     const { specId, mode = 'strict' } = args;
-    const spec = await specStore.getSpecFresh(projectId, specId);
-    if (!spec) {
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `Spec '${specId}' not found in project '${projectId}'`,
-                },
-            ],
-            isError: true,
+    const spec = await specStore.getSpecFresh(projectId, specId, args.projectPath);
+    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.specPath) : {};
-    const effectiveSpec = {
-        ...spec,
-        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 });
@@ -174,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-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/generate-execution-plan.js

@@ -1,5 +1,5 @@
 import { readFile } from 'node:fs/promises';
-import { join } from 'node:path';
+import { join, isAbsolute } from 'node:path';
 import { specStore, knowledgeStore, patternStore } from '../storage/index.js';
 import { ti } from '../i18n/index.js';
 import { generatePlanMarkdown, EXECUTION_PLAN_MARKER } from '../engine/dor-dod.js';
@@ -9,10 +9,14 @@ import { generateMobileDistributionPhase, isMobileDistributionSpec, } from '../e
 import { isDesktopReleaseSpec, generateDesktopDistributionPhase, } from '../engine/execution-plan/desktop-distribution.js';
 import { determineCriticalPath, findParallelizable, validateExecutionPlanGraph, } from '../engine/execution-plan/plan-utils.js';
 import { projectDataDir } from '../storage/base-store.js';
+import { resolveVerifiedSpecPath } from '../storage/project-identity.js';
 import { atomicWriteFile } from '../engine/safety/atomic-write-file.js';
-async function readSpecBody(spec) {
+async function readSpecBody(spec, projectPath) {
     try {
-        return await readFile(spec.specPath, 'utf-8');
+        const resolvedPath = !isAbsolute(spec.specPath) && projectPath
+            ? await resolveVerifiedSpecPath(spec.id, spec.specPath, projectPath)
+            : spec.specPath;
+        return await readFile(resolvedPath, 'utf-8');
     }
     catch {
         return null;
@@ -29,8 +33,8 @@ function invalidTaskPlanEntry(taskPlan) {
     const trimmedId = task.id.trim();
     return trimmedId.length > 0 ? trimmedId : '(missing id)';
 }
-async function loadGroundedContract(spec, projectId, specId) {
-    const body = await readSpecBody(spec);
+async function loadGroundedContract(spec, projectId, specId, projectPath) {
+    const body = await readSpecBody(spec, projectPath);
     const ownership = body
         ? extractCanonicalFileOwnership(body)
         : { present: false, toCreate: [], toModify: [], toTest: [], toTestDeclared: [], blockers: [] };
@@ -141,7 +145,7 @@ export async function handleGenerateExecutionPlan(args) {
             ],
         };
     }
-    const contract = await loadGroundedContract(spec, projectId, specId);
+    const contract = await loadGroundedContract(spec, projectId, specId, knowledge.projectPath);
     if (!contract.ok) {
         return {
             content: [

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',
@@ -12,15 +13,6 @@ const CORE_SKILL_TEMPLATES = [
     'planu-multi-teammate-review.md',
     'planu-context-assets.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);

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

package/dist/tools/tool-registry/deprecated-stubs.d.ts

@@ -1,4 +1,4 @@
-import type { ToolEntry } from '../tool-entry.js';
+import type { McpToolEntry } from '../tool-entry.js';
 /** Template for the deprecation message. Interpolated at runtime. */
 export declare const DEPRECATION_MESSAGE_TEMPLATE = "This tool has been migrated to a skill. Use the {skill} skill instead: {path}";
 /**
@@ -8,12 +8,12 @@ export declare const DEPRECATION_MESSAGE_TEMPLATE = "This tool has been migrated
 export declare const DEPRECATED_TOOLS: readonly ['execute_sdd_flow', 'implement_plan', 'multi_teammate_review', 'run_healing_loop', 'generate_orchestration_plan'];
 export type DeprecatedToolName = (typeof DEPRECATED_TOOLS)[number];
 /**
- * Create a ToolEntry-compatible deprecation stub.
+ * Create a McpToolEntry-compatible deprecation stub.
  *
  * - Tool stays registered → callers never see "unknown tool".
  * - Description starts with `[Deprecated]` → LLMs stop calling it.
  * - Handler always returns success (no `isError`) regardless of input.
  * - One stderr warning per process per tool (deduped).
  */
-export declare function makeDeprecationStub(toolName: string, replacementSkillPath: string, replacementSkillName: string): ToolEntry;
+export declare function makeDeprecationStub(toolName: string, replacementSkillPath: string, replacementSkillName: string): McpToolEntry;
 //# sourceMappingURL=deprecated-stubs.d.ts.map

package/dist/tools/tool-registry/deprecated-stubs.js

@@ -36,7 +36,7 @@ function warnOnce(toolName, skillPath) {
 // Factory
 // ---------------------------------------------------------------------------
 /**
- * Create a ToolEntry-compatible deprecation stub.
+ * Create a McpToolEntry-compatible deprecation stub.
  *
  * - Tool stays registered → callers never see "unknown tool".
  * - Description starts with `[Deprecated]` → LLMs stop calling it.