@planu/cli 5.3.5 → 5.3.7

package/dist/tools/safe-handler.js

@@ -3,7 +3,6 @@
 // instead of crashing the server. Includes cancellation-aware execution deadlines.
 import { withUsageTracking } from './usage-tracking.js';
 import { sanitizePath } from './sanitize-path.js';
-import { ensureHooksStarted } from './start-hooks.js';
 import { ensureWorkersStarted } from '../engine/workers/index.js';
 import { recordError } from '../storage/error-telemetry-store.js';
 import { hashProjectPath } from '../storage/base-store.js';
@@ -158,7 +157,6 @@ function sanitizeArgs(args, toolName) {
         // planu_status is a read-only snapshot. Starting background services here made
         // its latency depend on repository size and violated the MCP readOnlyHint.
         if (toolName !== 'planu_status') {
-            ensureHooksStarted(obj.projectPath);
             ensureWorkersStarted(obj.projectPath);
         }
         // Read-only check: track whether planu.json exists (no file writes)

package/dist/tools/start-hooks/engine.d.ts

@@ -1,13 +1,12 @@
 import type { ToolResult } from '../../types/index.js';
-import type { StartHooksInput, StopHooksInput } from '../../types/file-hooks.js';
+import type { StartHooksInput, StopHooksInput, HookStatusInput } from '../../types/file-hooks.js';
 import { HookEngine } from '../../engine/hooks/hook-engine.js';
 import { FileWatcher } from '../../engine/hooks/file-watcher.js';
 import { ConfigLoader } from '../../engine/hooks/config-loader.js';
 export declare function getEngineInstance(): HookEngine | null;
 export declare function getWatcherInstance(): FileWatcher | null;
 export declare function getConfigLoaderInstance(): ConfigLoader | null;
-export declare function ensureHooksStarted(projectPath: string): void;
 export declare function handleStartHooks(args: StartHooksInput): Promise<ToolResult>;
 export declare function handleStopHooks(_args: StopHooksInput): Promise<ToolResult>;
-export declare function handleHookStatus(): Promise<ToolResult>;
+export declare function handleHookStatus(args?: HookStatusInput): Promise<ToolResult>;
 //# sourceMappingURL=engine.d.ts.map

package/dist/tools/start-hooks/engine.js

@@ -4,7 +4,7 @@ import { EventBus } from '../../engine/hooks/event-bus.js';
 import { FileWatcher } from '../../engine/hooks/file-watcher.js';
 import { ConfigLoader } from '../../engine/hooks/config-loader.js';
 import { Debouncer } from '../../engine/hooks/debouncer.js';
-import { handleOnImplChange } from '../../engine/hooks/handlers/on-impl-change.js';
+import { handleOnImplChange, getLastImplChangeResult, } from '../../engine/hooks/handlers/on-impl-change.js';
 import { handleOnSpecChange } from '../../engine/hooks/handlers/on-spec-change.js';
 import { handleOnPushCheck, getLastPushCheckResult, } from '../../engine/hooks/handlers/on-push-check.js';
 import { handleOnSecurityCheck, isSecuritySensitiveFile, } from '../../engine/hooks/handlers/on-security-check.js';
@@ -13,7 +13,6 @@ import { listSpecs } from '../../storage/spec-store.js';
 import { hashProjectPath } from '../../storage/base-store.js';
 import { analyzeLivingSpec } from '../../engine/living-spec-analyzer.js';
 import { compactResult, formatKeyValue } from '../output-formatter.js';
-import { migrateAgentHooksIfNeeded } from '../../engine/hooks/agent-hook-migrator.js';
 // ---------------------------------------------------------------------------
 // Singleton state
 // ---------------------------------------------------------------------------
@@ -30,26 +29,27 @@ export function getWatcherInstance() {
 export function getConfigLoaderInstance() {
     return configLoaderInstance;
 }
-export function ensureHooksStarted(projectPath) {
-    migrateAgentHooksIfNeeded(projectPath);
-    if (engineInstance?.status().running) {
-        return;
+/**
+ * Resolve whether a hook type should run: it must be among the hooks the
+ * engine was explicitly started with, and the live ConfigLoader config must
+ * not disable it. Reads getConfig() live (not a start-time snapshot) so a
+ * hot config reload takes effect without restarting the engine (SPEC-1404).
+ * A hook type absent from config.hooks (e.g. on-impl-change in the defaults
+ * file) is treated as enabled, matching pre-existing behaviour.
+ */
+function isHookEnabled(hookType, requestedHooks) {
+    if (!requestedHooks.includes(hookType)) {
+        return false;
     }
-    void handleStartHooks({
-        projectPath,
-        hooks: [
-            'on-save',
-            'on-create',
-            'on-delete',
-            'on-commit',
-            'on-impl-change',
-            'on-spec-change',
-            'on-push-check',
-            'on-security-check',
-        ],
-    }).catch(() => {
-        // Silently swallow — hooks are best-effort
-    });
+    const config = configLoaderInstance?.getConfig();
+    /* v8 ignore next 3 -- defensive: unreachable while handleStartHooks owns configLoaderInstance's lifecycle */
+    if (!config) {
+        return false;
+    }
+    if (!config.enabled) {
+        return false;
+    }
+    return config.hooks[hookType]?.enabled !== false;
 }
 // ---------------------------------------------------------------------------
 // Start hooks
@@ -84,7 +84,7 @@ export async function handleStartHooks(args) {
     debouncerInstance = new Debouncer((event) => {
         const hookTypes = getApplicableHookTypes(event);
         for (const hookType of hookTypes) {
-            if (enabledHooks.includes(hookType)) {
+            if (isHookEnabled(hookType, enabledHooks)) {
                 void engineInstance?.dispatch(event, hookType);
             }
         }
@@ -100,7 +100,7 @@ export async function handleStartHooks(args) {
     configLoaderInstance.startWatching();
     engineInstance.start();
     watcherInstance.start();
-    registerAdvancedHandlers(engineInstance, enabledHooks, projectPath, config);
+    registerAdvancedHandlers(engineInstance, enabledHooks, projectPath);
     const eventBusFromEngine = engineInstance.getEventBus();
     subscribeStatusChangeHandler(eventBusFromEngine, 
     /* v8 ignore next 3 */ (_projectId) => Promise.resolve(true));
@@ -133,23 +133,40 @@ export async function handleStopHooks(_args) {
 // ---------------------------------------------------------------------------
 // Hook status
 // ---------------------------------------------------------------------------
-export async function handleHookStatus() {
+export async function handleHookStatus(args = {}) {
     await Promise.resolve();
     if (!engineInstance) {
         return compactResult(formatKeyValue({ running: false, activeHooks: 0, pendingEvents: 0, eventHistory: 0 }, 'Hook Status'));
     }
     const status = engineInstance.status();
     const eventBus = engineInstance.getEventBus();
-    return compactResult(formatKeyValue({
+    const summary = formatKeyValue({
         running: status.running,
         activeHooks: status.activeHooks.length,
         pendingEvents: status.pendingEvents,
         eventHistory: eventBus.getFullHistory().length,
-    }, 'Hook Status'));
+    }, 'Hook Status');
+    const diagnostic = getLastImplChangeResult(args.projectPath);
+    if (!diagnostic) {
+        return compactResult(summary);
+    }
+    return compactResult(summary + '\n\n' + formatImplChangeDiagnostic(diagnostic));
 }
 // ---------------------------------------------------------------------------
 // Private helpers
 // ---------------------------------------------------------------------------
+function formatImplChangeDiagnostic(diagnostic) {
+    const specLines = diagnostic.specsAnalyzed.map((s) => `  - ${s.specId}: ${String(s.completionPct)}%`);
+    return [
+        '### Last impl-change diagnostic',
+        `**changedFile**: ${diagnostic.changedFile}`,
+        `**anyAt100Percent**: ${String(diagnostic.autoReconciled)}`,
+        ...specLines,
+        '',
+        'Process-local observation, never applied automatically. ' +
+            'Apply it with reconcile_spec(livingSpec: true), or change lifecycle status with update_status.',
+    ].join('\n');
+}
 function getApplicableHookTypes(event) {
     switch (event.type) {
         case 'modify':
@@ -178,7 +195,7 @@ function makeAnalyzeSpecFn() {
             status: minimal.status,
             progressPath: minimal.progressPath,
         };
-        const report = await analyzeLivingSpec(specLike, projectPath);
+        const report = await analyzeLivingSpec(specLike, projectPath, { writeProgress: false });
         return {
             completionPct: report.completionPercent,
             progressUpdated: report.progressUpdated,
@@ -190,8 +207,8 @@ function makeAnalyzeSpecFn() {
         };
     };
 }
-function registerAdvancedHandlers(engine, enabledHooks, projectPath, config) {
-    if (enabledHooks.includes('on-impl-change')) {
+function registerAdvancedHandlers(engine, enabledHooks, projectPath) {
+    if (isHookEnabled('on-impl-change', enabledHooks)) {
         engine.register({
             name: 'on-impl-change',
             hookType: 'on-impl-change',
@@ -206,7 +223,7 @@ function registerAdvancedHandlers(engine, enabledHooks, projectPath, config) {
                 catch {
                     // Spec load failure — proceed without analysis
                 }
-                const analysisResult = await handleOnImplChange(event, projectPath, specs, makeAnalyzeSpecFn(), config.autoMarkDone !== false);
+                const analysisResult = await handleOnImplChange(event, projectPath, specs, makeAnalyzeSpecFn());
                 const firstSpecId = analysisResult
                     ? (analysisResult.specsAnalyzed[0]?.specId ?? null)
                     : null;
@@ -220,7 +237,7 @@ function registerAdvancedHandlers(engine, enabledHooks, projectPath, config) {
             },
         });
     }
-    if (enabledHooks.includes('on-spec-change')) {
+    if (isHookEnabled('on-spec-change', enabledHooks)) {
         engine.register({
             name: 'on-spec-change',
             hookType: 'on-spec-change',
@@ -237,7 +254,7 @@ function registerAdvancedHandlers(engine, enabledHooks, projectPath, config) {
             },
         });
     }
-    if (enabledHooks.includes('on-push-check')) {
+    if (isHookEnabled('on-push-check', enabledHooks)) {
         engine.register({
             name: 'on-push-check',
             hookType: 'on-push-check',
@@ -265,7 +282,7 @@ function registerAdvancedHandlers(engine, enabledHooks, projectPath, config) {
             },
         });
     }
-    if (enabledHooks.includes('on-security-check')) {
+    if (isHookEnabled('on-security-check', enabledHooks)) {
         engine.register({
             name: 'on-security-check',
             hookType: 'on-security-check',

package/dist/tools/start-hooks.d.ts

@@ -1,3 +1,3 @@
-export { getEngineInstance, getWatcherInstance, getConfigLoaderInstance, ensureHooksStarted, handleStartHooks, handleStopHooks, handleHookStatus, } from './start-hooks/engine.js';
+export { getEngineInstance, getWatcherInstance, getConfigLoaderInstance, handleStartHooks, handleStopHooks, handleHookStatus, } from './start-hooks/engine.js';
 export { handleConfigureHooks } from './start-hooks/configure.js';
 //# sourceMappingURL=start-hooks.d.ts.map

package/dist/tools/start-hooks.js

@@ -1,5 +1,4 @@
 // tools/start-hooks.ts — Barrel re-export. Implementation split into start-hooks/ subdirectory.
-// Existing imports (register-hooks-tools.ts, safe-handler.ts) continue to work unchanged.
-export { getEngineInstance, getWatcherInstance, getConfigLoaderInstance, ensureHooksStarted, handleStartHooks, handleStopHooks, handleHookStatus, } from './start-hooks/engine.js';
+export { getEngineInstance, getWatcherInstance, getConfigLoaderInstance, handleStartHooks, handleStopHooks, handleHookStatus, } from './start-hooks/engine.js';
 export { handleConfigureHooks } from './start-hooks/configure.js';
 //# sourceMappingURL=start-hooks.js.map

package/dist/tools/tool-registry/group-infra.js

@@ -28,6 +28,8 @@ import { handleValidateBrowser } from '../browser-validate-handler.js';
 import { WorkerStatusInputSchema, ConfigureWorkersInputSchema } from '../schemas/workers-schema.js';
 import { handleWorkerStatus } from '../worker-status-handler.js';
 import { handleConfigureWorkers } from '../configure-workers-handler.js';
+// ── Hook tools (SPEC-1404: explicit start, no longer auto-started) ──────────
+import { handleStartHooks, handleStopHooks, handleHookStatus } from '../start-hooks.js';
 // ── Plugin tools (register-plugin-tools.ts) ──────────────────────────────────
 import { handleManagePlugins } from '../manage-plugins-handler.js';
 import { handleScaffoldPlugin } from '../scaffold-plugin-handler.js';
@@ -434,6 +436,40 @@ export function registerInfraGroupTools(server) {
         },
         annotations: { title: 'Configure Workers', readOnlyHint: false },
     }, safeGoverned('configure_workers', (args) => handleConfigureWorkers(args)));
+    // ── Hook tools (SPEC-1404: explicit start, watcher never mutates spec state) ─
+    server.registerTool('start_hooks', {
+        description: 'Start the filesystem hook engine for a project: watches source and spec files and runs ' +
+            'diagnostic-only analysis on change (never mutates spec lifecycle status). Must be called ' +
+            'explicitly — hooks no longer start implicitly on other tool calls.',
+        inputSchema: {
+            projectPath: z.string().describe('Absolute path to the project root directory to watch'),
+            hooks: z
+                .array(z.string())
+                .optional()
+                .describe('Hook types to enable. Valid values: on-save, on-create, on-delete, on-test-pass, ' +
+                'on-commit, on-impl-change, on-spec-change, on-push-check, on-security-check. ' +
+                'Defaults to on-save, on-create, on-delete, on-impl-change, on-spec-change, on-security-check.'),
+        },
+        annotations: { title: 'Start Hooks', readOnlyHint: false },
+    }, safe(async (args) => handleStartHooks(args)));
+    server.registerTool('stop_hooks', {
+        description: 'Stop the running filesystem hook engine and release its watcher, debouncer, and config-loader resources.',
+        inputSchema: {
+            reason: z.string().optional().describe('Optional reason for stopping the hook engine'),
+        },
+        annotations: { title: 'Stop Hooks', readOnlyHint: false },
+    }, safe(async (args) => handleStopHooks(args)));
+    server.registerTool('hook_status', {
+        description: 'Show whether the filesystem hook engine is running, its active hooks and pending events, ' +
+            'and the last diagnostic-only impl-change analysis (if any). Never applies changes.',
+        inputSchema: {
+            projectPath: z
+                .string()
+                .optional()
+                .describe('Absolute path to the project root, used to look up its diagnostic snapshot'),
+        },
+        annotations: { title: 'Hook Status', readOnlyHint: true },
+    }, safe(async (args) => handleHookStatus(args)));
     // ── Plugin tools ───────────────────────────────────────────────────────────
     server.registerTool('manage_plugins', {
         description: 'Manage Planu plugin lifecycle: search, list, activate, deactivate, uninstall, info. ' +

package/dist/tools/update-status/transition-guard.js

@@ -540,12 +540,25 @@ export function checkChallengeGate(spec, newStatus) {
             },
         };
     }
+    if (!Array.isArray(report.findings)) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Challenge gate blocked: the stored challenge report predates finding-level tracking, so its findings cannot be resolved. Run challenge_spec(specId="${spec.id}") to regenerate it before transitioning to review.`,
+                },
+            ],
+            isError: true,
+            structuredContent: {
+                error: 'CHALLENGE_GATE_BLOCKED',
+                code: 'STALE_CHALLENGE_REPORT',
+                fixHint: `Run challenge_spec(specId="${spec.id}") to regenerate the report with findings, then record resolution evidence.`,
+            },
+        };
+    }
     const resolutionEvidence = getResolvedChallengeEvidence(report);
     const addressedCount = resolutionEvidence.length;
-    const findingsCount = Array.isArray(report.findings)
-        ? report.findings.length
-        : report.totalScenarios;
-    const requiredCount = requiredResolvedChallenges(findingsCount);
+    const requiredCount = requiredResolvedChallenges(new Set(report.findings.map((finding) => finding.scenario)).size);
     if (addressedCount < requiredCount) {
         return {
             content: [

package/dist/tools/validate-assurance.js

@@ -20,7 +20,7 @@ function readChangedSpecLogicFiles(projectPath) {
             'src/tools/create-spec',
             'src/tools/validate.ts',
             'src/engine',
-        ], { encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'] });
+        ], { encoding: 'utf-8', timeout: 5_000, stdio: ['ignore', 'pipe', 'ignore'] });
         changedFiles = output
             .split('\n')
             .map((line) => line.trim())

package/dist/tools/validate-lint.js

@@ -128,7 +128,7 @@ export async function runLintCheck(projectPath, lintCommand, context = {}) {
                     source: 'local:planu-validate',
                 });
             }
-            return { passed: true, command, issueCount: 0, output };
+            return { passed: false, command, issueCount: 1, output };
         }
         const raw = commandOutput(err);
         const output = formatLintFailureDiagnostics(plan, raw);

package/dist/tools/validate.d.ts

@@ -4,6 +4,7 @@ import type { ValidateInput, ToolResult, ContractSpec, ContractValidation } from
 import type { ValidateWorkerProgress } from '../types/validate-worker.js';
 export { validateContractCompliance };
 export type { ContractSpec, ContractValidation };
+export declare function createValidationStageRunner(onProgress?: (progress: ValidateWorkerProgress) => void): <T>(phase: string, command: string, work: () => T | Promise<T>) => Promise<T>;
 /** Public MCP boundary: persist and acknowledge validation work without running it inline. */
 export declare function handleValidate(args: ValidateInput): Promise<ToolResult>;
 export declare function executeValidate(args: ValidateInput, server?: McpServer, onProgress?: (progress: ValidateWorkerProgress) => void): Promise<ToolResult>;

package/dist/tools/validate.js

@@ -85,7 +85,26 @@ import { resolveValidationWorktree, ValidationWorktreeError, } from '../engine/v
 // Re-export for external use (SPEC-018)
 export { validateContractCompliance };
 const VALIDATION_GATE_TOTAL = 8;
-function createValidationStageRunner(onProgress) {
+const GATE_DEADLINE_EXEMPT_PHASES = new Set(['lint', 'compliance']);
+async function runWithGateDeadline(phase, command, work) {
+    if (GATE_DEADLINE_EXEMPT_PHASES.has(phase)) {
+        return work();
+    }
+    const deadlineMs = getRuntimePolicy().validation.perGateTimeoutMs;
+    let timer;
+    const deadline = new Promise((_resolve, reject) => {
+        timer = setTimeout(() => {
+            reject(new Error(`[Planu] validate gate "${phase}" (${command}) exceeded its ${String(deadlineMs)}ms deadline`));
+        }, deadlineMs);
+    });
+    try {
+        return await Promise.race([Promise.resolve(work()), deadline]);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+export function createValidationStageRunner(onProgress) {
     const startedAt = Date.now();
     let completedGates = 0;
     return async (phase, command, work) => {
@@ -102,7 +121,7 @@ function createValidationStageRunner(onProgress) {
         };
         emit('running');
         try {
-            const result = await work();
+            const result = await runWithGateDeadline(phase, command, work);
             completedGates += 1;
             emit('passed');
             return result;

package/dist/types/file-hooks.d.ts

@@ -26,12 +26,6 @@ export interface FileHookConfig {
     rateLimitPerFileMs: number;
     /** Per-hook-type configuration */
     hooks: Record<string, FileHookTypeConfig>;
-    /**
-     * When true (default), automatically mark a spec as 'done' when its
-     * implementation analysis reaches 100% completion. Set to false to disable
-     * the auto-done behaviour and only log the milestone.
-     */
-    autoMarkDone?: boolean;
 }
 export interface DebouncerOptions {
     /** Debounce window in milliseconds (default: 300) */
@@ -294,6 +288,10 @@ export interface StopHooksInput {
     /** Optional reason for stopping the hook engine */
     reason?: string;
 }
+export interface HookStatusInput {
+    /** Absolute path to the project root, used to look up its diagnostic snapshot */
+    projectPath?: string;
+}
 export interface ConfigureHooksInput {
     /** Absolute path to the project root directory */
     projectPath: string;

package/dist/types/index.d.ts

@@ -63,7 +63,6 @@ export * from './commercial-migration.js';
 export * from './coverage.js';
 export * from './ai-cost.js';
 export * from './hooks.js';
-export * from './hook-status-update.js';
 export * from './ci.js';
 export * from './spec-templates.js';
 export * from './spec-generator.js';

package/dist/types/index.js

@@ -64,7 +64,6 @@ export * from './commercial-migration.js';
 export * from './coverage.js';
 export * from './ai-cost.js';
 export * from './hooks.js';
-export * from './hook-status-update.js';
 export * from './ci.js';
 export * from './spec-templates.js';
 export * from './spec-generator.js';

package/dist/types/mcp.d.ts

@@ -223,23 +223,4 @@ export interface ListSpecPromptsArgs {
 export interface SpecPromptRegistryEntry extends SpecPromptDefinition {
     specId: string;
 }
-export interface ClaudeHookEntry {
-    type: string;
-    prompt?: string;
-    model?: string;
-    statusMessage?: string;
-    command?: string;
-    once?: boolean;
-    timeout?: number;
-    [key: string]: unknown;
-}
-export interface ClaudeHookMatcher {
-    matcher: string;
-    hooks: ClaudeHookEntry[];
-}
-export type ClaudeHooksMap = Record<string, ClaudeHookMatcher[]>;
-export interface ClaudeSettings {
-    hooks?: ClaudeHooksMap;
-    [key: string]: unknown;
-}
 //# sourceMappingURL=mcp.d.ts.map

package/dist/types/runtime-policy.d.ts

@@ -24,6 +24,7 @@ export interface RuntimePolicy {
     validation: {
         defaultDeadlineMs: number;
         durableLintTimeoutMs: number;
+        perGateTimeoutMs: number;
         complianceCommandTimeoutMs: number;
         noProgressTimeoutMs: number;
         submissionLockWaitMs: number;

package/dist/types/spec/core.d.ts

@@ -266,6 +266,11 @@ export interface LivingSpecReport {
     analyzedAt: string;
     progressUpdated: boolean;
 }
+/** Options for analyzeLivingSpec — controls whether ## Progress is written to spec.md. */
+export interface AnalyzeLivingSpecOptions {
+    /** When true, write the analysis into spec.md's ## Progress section. Default: false. */
+    writeProgress?: boolean;
+}
 export interface SpecVersion {
     specId: string;
     version: number;

package/dist/types/spec/inputs.d.ts

@@ -1,5 +1,6 @@
 import type { SpecStatus, SpecType, SpecScope, SpecTarget, ToolResult } from '../common/index.js';
 import type { Actuals } from '../estimation.js';
+import type { GlobalConfig } from '../project/config-metrics.js';
 import type { ProjectKnowledge } from '../project.js';
 import type { Spec, ChecklistCategory, SpecDiagram, SpecSplitSuggestion, ReconcileChange } from './core.js';
 export interface ReconciliationInvocationContext {
@@ -230,10 +231,25 @@ export interface FilesystemImportDeps {
     listSpecs: (projectId: string) => Promise<Spec[]>;
     createSpec: (projectId: string, spec: Spec) => Promise<Spec>;
     getSpecFresh?: (projectId: string, specId: string) => Promise<Spec | null>;
+    getGlobalConfig?: () => Promise<Partial<GlobalConfig>>;
 }
 export interface PortableIndexReconciliationResult extends FilesystemImportResult {
     repositoryFilesChanged: string[];
 }
+export interface ImportEntryContext {
+    projectPath: string;
+    projectId: string;
+    deps: FilesystemImportDeps;
+    options: {
+        strictPortableContract?: boolean;
+    };
+    specsRoot: string;
+    globalConfig: Partial<GlobalConfig>;
+    storeSpecs: Spec[];
+    specsById: Map<string, Spec>;
+    importedSpecIds: string[];
+    failures: FilesystemImportFailure[];
+}
 export type ChallengeSpecFocus = 'failures' | 'concurrency' | 'scale' | 'security' | 'data-consistency';
 export type { ScopeFilter, ScopeFilterConfig } from './core.js';
 export interface SplitAnalysisInput {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@planu/cli",
-  "version": "5.3.5",
+  "version": "5.3.7",
   "description": "Planu — MCP Server for Spec Driven Development with native Rust acceleration for hot paths. Cross-platform (Linux/macOS/Windows, x64/arm64, glibc/musl).",
   "type": "module",
   "main": "dist/index.js",
@@ -35,14 +35,14 @@
     "packageName": "@planu/core"
   },
   "optionalDependencies": {
-    "@planu/core-darwin-arm64": "5.3.5",
-    "@planu/core-darwin-x64": "5.3.5",
-    "@planu/core-linux-arm64-gnu": "5.3.5",
-    "@planu/core-linux-arm64-musl": "5.3.5",
-    "@planu/core-linux-x64-gnu": "5.3.5",
-    "@planu/core-linux-x64-musl": "5.3.5",
-    "@planu/core-win32-arm64-msvc": "5.3.5",
-    "@planu/core-win32-x64-msvc": "5.3.5"
+    "@planu/core-darwin-arm64": "5.3.7",
+    "@planu/core-darwin-x64": "5.3.7",
+    "@planu/core-linux-arm64-gnu": "5.3.7",
+    "@planu/core-linux-arm64-musl": "5.3.7",
+    "@planu/core-linux-x64-gnu": "5.3.7",
+    "@planu/core-linux-x64-musl": "5.3.7",
+    "@planu/core-win32-arm64-msvc": "5.3.7",
+    "@planu/core-win32-x64-msvc": "5.3.7"
   },
   "engines": {
     "node": ">=24.0.0"

package/planu-native.json

@@ -1,7 +1,7 @@
 {
   "name": "dev.planu.native",
   "displayName": "Planu Native Lightweight Surface",
-  "version": "5.3.5",
+  "version": "5.3.7",
   "packageName": "@planu/cli",
   "modes": {
     "lightweight": {

package/planu-plugin.json

@@ -2,7 +2,7 @@
   "name": "dev.planu.cli",
   "displayName": "Planu — Spec Driven Development",
   "description": "Manage software specs, estimations, and autonomous SDD workflows. Language-agnostic MCP server for Claude Code.",
-  "version": "5.3.5",
+  "version": "5.3.7",
   "icon": "assets/plugin/icon.svg",
   "command": ["npx", "@planu/cli@latest"],
   "packageName": "@planu/cli",

package/dist/engine/hooks/agent-hook-migrator.d.ts

@@ -1,9 +0,0 @@
-/**
- * Scan .claude/settings.json (project-level) and ~/.claude/settings.json (global)
- * for deprecated type:"agent" hooks and migrate them to type:"command" equivalents.
- *
- * Fire-and-forget safe: never throws, logs to stderr only.
- * Idempotent: each projectPath is only migrated once per process lifetime.
- */
-export declare function migrateAgentHooksIfNeeded(projectPath: string): void;
-//# sourceMappingURL=agent-hook-migrator.d.ts.map