@planu/cli 5.3.4 → 5.3.6

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/dod-gates.js

@@ -285,7 +285,7 @@ function validationReceiptGateError(specId, reason) {
         },
     };
 }
-function doneReviewDigestError(specId, code, message) {
+function doneReviewDigestError(specId, code, message, digests) {
     const artifactPath = `external Planu project data: handoffs/${specId}/validation-report.json`;
     const fixHint = 'Run validate, then recompute the sha256 digest from the exact report bytes.';
     return {
@@ -294,7 +294,7 @@ function doneReviewDigestError(specId, code, message) {
         structuredContent: {
             error: code,
             code: 422,
-            context: { specId, artifactPath },
+            context: { specId, artifactPath, ...digests },
             fixHint,
         },
     };
@@ -430,7 +430,7 @@ async function checkDoneReviewDigest(specId, projectId, implementationReviewDige
     }
     const observed = `sha256:${createHash('sha256').update(reportResult).digest('hex')}`;
     if (observed !== implementationReviewDigest) {
-        return doneReviewDigestError(specId, 'DONE_REVIEW_DIGEST_MISMATCH', 'The implementation review digest does not match the persisted validation report.');
+        return doneReviewDigestError(specId, 'DONE_REVIEW_DIGEST_MISMATCH', 'The implementation review digest does not match the persisted validation report.', { received: implementationReviewDigest, expected: observed });
     }
     let decoded;
     try {

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/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/reconcile.d.ts

@@ -1,58 +1,46 @@
-/**
- * Sections whose values do not appear as literal text in spec.md body —
- * applied/verified at the metadata layer, never via string-replace.
- * Shared by apply-changes.ts (skip) and verify-write.ts (skip).
- */
-export declare const RECONCILE_METADATA_SECTIONS: ReadonlySet<string>;
-/** A single failed post-write verification entry (Bug D). */
+export declare const SECTIONS_WITHOUT_LITERAL_BODY_TEXT: ReadonlySet<string>;
 export interface VerifyWriteFailure {
     section: string;
     newValue: string;
     reason: string;
 }
-/** Result of verifyWriteSucceeded (Bug D). */
 export interface VerifyWriteResult {
     verified: boolean;
     missingChanges: VerifyWriteFailure[];
 }
-/** A change that could not be applied to spec.md body (Bug D). */
 export interface SkippedChange {
     section: string;
     originalValue: string;
     reason: string;
+    reasonCategory: 'skipped' | 'ambiguous';
 }
-/** Result of applyChangesToSpec (Bug D). */
 export interface ApplyChangesResult {
     applied: number;
     skipped: SkippedChange[];
     fileWritten: boolean;
 }
-/** Body bounds of a markdown section, used by apply-changes' anchoring. */
+export interface ApplyChangesToSpecFilesResult {
+    auditWritten: boolean;
+}
 export interface SectionBounds {
     start: number;
     end: number;
 }
-/** Parsed snapshot of status.json used by status-reconciler (Bug G). */
 export interface CurrentStatus {
     totalSpecs: number;
     content: Record<string, unknown>;
-    /** True when status.json exists; false when missing (ENOENT). */
     exists: boolean;
-    /** True when status.json existed but could not be parsed/read for non-ENOENT reasons. */
     corrupt: boolean;
 }
-/** Result of reconcileStatusFromDisk (Bug G). */
 export interface StatusReconcileResult {
     reconciled: boolean;
     before: number;
     after: number;
 }
 import type { ProjectKnowledge } from './project/core.js';
-/** Result when a project was resolved via resolveProjectFromPath (Bug F). */
 export interface ResolvedProject {
     projectId: string;
     knowledge: ProjectKnowledge;
-    /** True when knowledge was recovered from disk fingerprint. */
     recovered: boolean;
 }
 //# sourceMappingURL=reconcile.d.ts.map

package/dist/types/reconcile.js

@@ -1,10 +1,4 @@
-// types/reconcile.ts — SPEC-1011: Types for reconcile engine modules
-/**
- * Sections whose values do not appear as literal text in spec.md body —
- * applied/verified at the metadata layer, never via string-replace.
- * Shared by apply-changes.ts (skip) and verify-write.ts (skip).
- */
-export const RECONCILE_METADATA_SECTIONS = new Set([
+export const SECTIONS_WITHOUT_LITERAL_BODY_TEXT = new Set([
     'estimation',
     'cost',
     'status',

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.4",
+  "version": "5.3.6",
   "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.4",
-    "@planu/core-darwin-x64": "5.3.4",
-    "@planu/core-linux-arm64-gnu": "5.3.4",
-    "@planu/core-linux-arm64-musl": "5.3.4",
-    "@planu/core-linux-x64-gnu": "5.3.4",
-    "@planu/core-linux-x64-musl": "5.3.4",
-    "@planu/core-win32-arm64-msvc": "5.3.4",
-    "@planu/core-win32-x64-msvc": "5.3.4"
+    "@planu/core-darwin-arm64": "5.3.6",
+    "@planu/core-darwin-x64": "5.3.6",
+    "@planu/core-linux-arm64-gnu": "5.3.6",
+    "@planu/core-linux-arm64-musl": "5.3.6",
+    "@planu/core-linux-x64-gnu": "5.3.6",
+    "@planu/core-linux-x64-musl": "5.3.6",
+    "@planu/core-win32-arm64-msvc": "5.3.6",
+    "@planu/core-win32-x64-msvc": "5.3.6"
   },
   "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.4",
+  "version": "5.3.6",
   "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.4",
+  "version": "5.3.6",
   "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