@lousy-agents/cli 5.19.0 → 5.19.1

package/api/copilot-with-fastify/package-lock.json

@@ -18,14 +18,14 @@
             },
             "devDependencies": {
                 "@biomejs/biome": "2.5.3",
-                "@lousy-agents/mcp": "5.18.2",
+                "@lousy-agents/mcp": "5.19.0",
                 "@modelcontextprotocol/server-sequential-thinking": "2026.7.4",
                 "@testcontainers/postgresql": "12.0.4",
                 "@types/node": "24.13.3",
                 "@upstash/context7-mcp": "3.2.5",
                 "chance": "1.1.13",
                 "testcontainers": "12.0.4",
-                "tsx": "4.23.4",
+                "tsx": "4.23.5",
                 "typescript": "7.0.2",
                 "vitest": "4.1.10"
             }
@@ -972,9 +972,9 @@
             }
         },
         "node_modules/@lousy-agents/mcp": {
-            "version": "5.18.2",
-            "resolved": "https://registry.npmjs.org/@lousy-agents/mcp/-/mcp-5.18.2.tgz",
-            "integrity": "sha512-KGXiIqXT/9s3BN0W3Ag2p4kr0RPbVC3JgrItIr3iEmLsSku+rik6C8f9EXYarT3eud92aZNvrN26qJZYcg2BpA==",
+            "version": "5.19.0",
+            "resolved": "https://registry.npmjs.org/@lousy-agents/mcp/-/mcp-5.19.0.tgz",
+            "integrity": "sha512-3Hm79pTx2Gpis3vd1sJWfJ+CSIYUAqF6AuU0VCNwhGqfO9V34IskwDsmp/WPTy6F6Io1FUhm7be7G3x4/MWI/g==",
             "dev": true,
             "license": "BSD-2-Clause-Patent",
             "dependencies": {
@@ -5851,9 +5851,9 @@
             "optional": true
         },
         "node_modules/tsx": {
-            "version": "4.23.4",
-            "resolved": "https://registry.npmjs.org/tsx/-/tsx-4.23.4.tgz",
-            "integrity": "sha512-ZiUQ8oT/KzN51mJUWPqARYqwFLFJZtGZipRkw1ynHMr9vy3eU77m5yfF3Gzm6meEg/beW+lUu3fHYgskTN2oVQ==",
+            "version": "4.23.5",
+            "resolved": "https://registry.npmjs.org/tsx/-/tsx-4.23.5.tgz",
+            "integrity": "sha512-rw55FUaqOoI7RvlQwLbhO4nSDApnQ4/CykPuiQ/EPvtrX3WA9Ig55jIt9VvbBJbzJuj12ueRu4PMZ2SxPVbihg==",
             "dev": true,
             "license": "MIT",
             "dependencies": {

package/api/copilot-with-fastify/package.json

@@ -29,14 +29,14 @@
     },
     "devDependencies": {
         "@biomejs/biome": "2.5.3",
-        "@lousy-agents/mcp": "5.18.2",
+        "@lousy-agents/mcp": "5.19.0",
         "@modelcontextprotocol/server-sequential-thinking": "2026.7.4",
         "@testcontainers/postgresql": "12.0.4",
         "@types/node": "24.13.3",
         "@upstash/context7-mcp": "3.2.5",
         "chance": "1.1.13",
         "testcontainers": "12.0.4",
-        "tsx": "4.23.4",
+        "tsx": "4.23.5",
         "typescript": "7.0.2",
         "vitest": "4.1.10"
     }

package/cli/copilot-with-citty/package.json

@@ -20,12 +20,12 @@
     },
     "devDependencies": {
         "@biomejs/biome": "2.5.3",
-        "@lousy-agents/mcp": "5.18.2",
+        "@lousy-agents/mcp": "5.19.0",
         "@modelcontextprotocol/server-sequential-thinking": "2026.7.4",
         "@types/node": "24.13.3",
         "@upstash/context7-mcp": "3.2.5",
         "chance": "1.1.13",
-        "tsx": "4.23.4",
+        "tsx": "4.23.5",
         "typescript": "7.0.2",
         "vitest": "4.1.10"
     }

package/dist/index.js

@@ -3032,7 +3032,7 @@ exports.basename = (path, { windows } = {}) => {
 
 
 },
-4140(__unused_rspack_module, __unused_rspack___webpack_exports__, __webpack_require__) {
+6567(__unused_rspack_module, __unused_rspack___webpack_exports__, __webpack_require__) {
 // NAMESPACE OBJECT: ../../node_modules/micromark/lib/constructs.js
 var constructs_namespaceObject = {};
 __webpack_require__.r(constructs_namespaceObject);
@@ -11689,11 +11689,11 @@ const $ZodXor = /*@__PURE__*/ (/* unused pure expression or super */ null && (co
 })));
 const $ZodDiscriminatedUnion = 
 /*@__PURE__*/
-(/* unused pure expression or super */ null && (core.$constructor("$ZodDiscriminatedUnion", (inst, def) => {
+$constructor("$ZodDiscriminatedUnion", (inst, def) => {
     def.inclusive = false;
     $ZodUnion.init(inst, def);
     const _super = inst._zod.parse;
-    util.defineLazy(inst._zod, "propValues", () => {
+    defineLazy(inst._zod, "propValues", () => {
         const propValues = {};
         for (const option of def.options) {
             const pv = option._zod.propValues;
@@ -11709,7 +11709,7 @@ const $ZodDiscriminatedUnion =
         }
         return propValues;
     });
-    const disc = util.cached(() => {
+    const disc = util_cached(() => {
         const opts = def.options;
         const map = new Map();
         for (const o of opts) {
@@ -11727,7 +11727,7 @@ const $ZodDiscriminatedUnion =
     });
     inst._zod.parse = (payload, ctx) => {
         const input = payload.value;
-        if (!util.isObject(input)) {
+        if (!util_isObject(input)) {
             payload.issues.push({
                 code: "invalid_type",
                 expected: "object",
@@ -11760,7 +11760,7 @@ const $ZodDiscriminatedUnion =
         });
         return payload;
     };
-})));
+});
 const $ZodIntersection = /*@__PURE__*/ $constructor("$ZodIntersection", (inst, def) => {
     $ZodType.init(inst, def);
     inst._zod.parse = (payload, ctx) => {
@@ -15937,17 +15937,17 @@ function xor(options, params) {
         ...util.normalizeParams(params),
     });
 }
-const ZodDiscriminatedUnion = /*@__PURE__*/ (/* unused pure expression or super */ null && (core.$constructor("ZodDiscriminatedUnion", (inst, def) => {
+const ZodDiscriminatedUnion = /*@__PURE__*/ $constructor("ZodDiscriminatedUnion", (inst, def) => {
     ZodUnion.init(inst, def);
-    core.$ZodDiscriminatedUnion.init(inst, def);
-})));
+    $ZodDiscriminatedUnion.init(inst, def);
+});
 function discriminatedUnion(discriminator, options, params) {
     // const [options, params] = args;
     return new ZodDiscriminatedUnion({
         type: "union",
         options,
         discriminator,
-        ...util.normalizeParams(params),
+        ...normalizeParams(params),
     });
 }
 const ZodIntersection = /*@__PURE__*/ $constructor("ZodIntersection", (inst, def) => {
@@ -33047,11 +33047,28 @@ async function walkMarkdownFiles(targetDir, resolvedRootDir, dir, depth, deriveN
 
 /** Maximum hook config file size: 1 MB */ const MAX_CONFIG_FILE_BYTES = 1_048_576;
 /** Matches the Copilot hook key `"preToolUse":` to detect hook section presence */ const COPILOT_HOOK_PATTERN = /"preToolUse"\s*:/;
-/** Matches the Claude hook key `"PreToolUse":` to detect hook section presence */ const CLAUDE_HOOK_PATTERN = /"PreToolUse"\s*:/;
+/** Matches the Claude hook key `"hooks":` to detect hook section presence */ const CLAUDE_HOOK_PATTERN = /"hooks"\s*:/;
 /** Catalog hook config paths converted to OS-native relative paths. */ const HOOK_CONFIG_PATHS = hookConfigPaths().map((entry)=>({
         relativePath: (0,external_node_path_.join)(...entry.relativePath.split("/")),
         platform: entry.platform
     }));
+/**
+ * Structural check for a `hooks` object on a parsed settings file.
+ *
+ * Uses `Object.hasOwn` so a `hooks` key inherited from the prototype chain
+ * cannot make an unrelated file look like a hook config. Arrays are rejected
+ * even though `typeof [] === "object"`, because a hooks section is keyed by
+ * event name.
+ */ function hasHooksSection(parsed) {
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+        return false;
+    }
+    if (!Object.hasOwn(parsed, "hooks")) {
+        return false;
+    }
+    const hooks = parsed.hooks;
+    return hooks !== null && typeof hooks === "object" && !Array.isArray(hooks);
+}
 /**
  * File system implementation of the hook config lint gateway.
  */ class FileSystemHookConfigGateway {
@@ -33098,14 +33115,24 @@ async function walkMarkdownFiles(targetDir, resolvedRootDir, dir, depth, deriveN
         return readFileNoFollow(filePath, MAX_CONFIG_FILE_BYTES);
     }
     /**
-     * Lightweight heuristic to check if a file may contain a pre-tool-use hooks section.
-     * Uses substring search rather than JSON.parse so that files with invalid JSON are
-     * still discovered and surfaced as `hook/invalid-json` diagnostics by the use case.
+     * Checks whether a file may contain a hooks section.
+     *
+     * Claude Code settings files carry much more than hooks, and the `hooks`
+     * key is generic enough to appear inside unrelated string values, so a
+     * parsed structural check is used when the JSON is well-formed. Malformed
+     * JSON falls back to a substring search so the file is still discovered
+     * and surfaced as a `hook/invalid-json` diagnostic by the use case.
      */ mayContainHookSection(content, platform) {
         if (platform === "copilot") {
             return COPILOT_HOOK_PATTERN.test(content);
         }
-        return CLAUDE_HOOK_PATTERN.test(content);
+        let parsed;
+        try {
+            parsed = JSON.parse(content);
+        } catch  {
+            return CLAUDE_HOOK_PATTERN.test(content);
+        }
+        return hasHooksSection(parsed);
     }
 }
 /**
@@ -52849,6 +52876,7 @@ async function resolveConfigPathOrNull(targetDir, relativePath) {
         "hook/invalid-json": "error",
         "hook/invalid-config": "error",
         "hook/missing-command": "error",
+        "hook/unknown-event": "error",
         "hook/missing-matcher": "warn",
         "hook/missing-timeout": "warn"
     },
@@ -53153,6 +53181,167 @@ async function resolveConfigPathOrNull(targetDir, relativePath) {
     return lines[0]?.trim() === "---";
 }
 
+;// CONCATENATED MODULE: ../core/src/entities/claude-hook-schema.ts
+// biome-ignore-all lint/style/useNamingConvention: Claude Code API uses PascalCase hook event names (PreToolUse) and snake_case handler types (mcp_tool)
+/**
+ * Zod schemas for the Claude Code hooks configuration format.
+ *
+ * Lives in entities (Layer 1) so that use cases can import it without
+ * violating the dependency rule, mirroring `copilot-hook-schema.ts`.
+ *
+ * Modelled on https://code.claude.com/docs/en/hooks. Claude Code settings
+ * files carry far more than hooks, so the top level is permissive
+ * (`.passthrough()`); the `hooks` section itself is strict so that a
+ * misspelled event name — which silently never fires — is reported.
+ */ 
+const MAX_HOOKS_PER_ENTRY = 100;
+/**
+ * Events that accept a `matcher`. The remainder fire unconditionally, so a
+ * missing `matcher` is only worth reporting for the events listed here.
+ */ const MATCHER_SUPPORTING_EVENTS = new Set([
+    "PreToolUse",
+    "PostToolUse",
+    "PostToolUseFailure",
+    "PermissionRequest",
+    "PermissionDenied",
+    "SessionStart",
+    "Setup",
+    "SessionEnd",
+    "Notification",
+    "SubagentStart",
+    "SubagentStop",
+    "PreCompact",
+    "PostCompact",
+    "ConfigChange",
+    "DirectoryAdded",
+    "FileChanged",
+    "StopFailure",
+    "InstructionsLoaded",
+    "UserPromptExpansion",
+    "Elicitation",
+    "ElicitationResult"
+]);
+/** Fields every handler type accepts regardless of `type`. */ const sharedHandlerFields = {
+    if: schemas_string().optional(),
+    timeout: schemas_number().positive().optional(),
+    statusMessage: schemas_string().optional(),
+    once: schemas_boolean().optional()
+};
+/** Regex that allows standard env var names and rejects __proto__ (the prototype-polluting key). */ const ENV_KEY_PATTERN = /^(?!__proto__$)[a-zA-Z_][a-zA-Z0-9_]*$/;
+const ClaudeCommandHandlerSchema = schemas_object({
+    ...sharedHandlerFields,
+    type: schemas_literal("command"),
+    command: schemas_string().min(1, "Hook command must not be empty"),
+    args: schemas_array(schemas_string()).optional(),
+    shell: schemas_enum([
+        "bash",
+        "powershell"
+    ]).optional(),
+    async: schemas_boolean().optional(),
+    asyncRewake: schemas_boolean().optional()
+}).strict();
+const ClaudeHttpHandlerSchema = schemas_object({
+    ...sharedHandlerFields,
+    type: schemas_literal("http"),
+    url: schemas_string().min(1, "Hook url must not be empty"),
+    headers: schemas_record(schemas_string(), schemas_string()).optional(),
+    allowedEnvVars: schemas_array(schemas_string().regex(ENV_KEY_PATTERN, "Hook allowedEnvVars entry must be a valid identifier (no prototype-polluting keys)")).optional()
+}).strict();
+const ClaudeMcpToolHandlerSchema = schemas_object({
+    ...sharedHandlerFields,
+    type: schemas_literal("mcp_tool"),
+    server: schemas_string().min(1, "Hook server must not be empty"),
+    tool: schemas_string().min(1, "Hook tool must not be empty"),
+    input: schemas_record(schemas_string(), unknown()).optional()
+}).strict();
+const ClaudePromptHandlerSchema = schemas_object({
+    ...sharedHandlerFields,
+    type: schemas_literal("prompt"),
+    prompt: schemas_string().min(1, "Hook prompt must not be empty"),
+    model: schemas_string().optional()
+}).strict();
+const ClaudeAgentHandlerSchema = schemas_object({
+    ...sharedHandlerFields,
+    type: schemas_literal("agent"),
+    prompt: schemas_string().min(1, "Hook prompt must not be empty"),
+    model: schemas_string().optional()
+}).strict();
+/**
+ * A single hook handler. Discriminated on `type` so that each handler is
+ * validated against its own required fields — an `http` handler is not
+ * expected to carry a `command`, and vice versa.
+ */ const ClaudeHookHandlerSchema = discriminatedUnion("type", [
+    ClaudeCommandHandlerSchema,
+    ClaudeHttpHandlerSchema,
+    ClaudeMcpToolHandlerSchema,
+    ClaudePromptHandlerSchema,
+    ClaudeAgentHandlerSchema
+]);
+/**
+ * A single entry within a hook event array.
+ *
+ * `matcher` is optional for every event: Claude Code treats an omitted
+ * matcher as "match all", and many events accept no matcher at all.
+ */ const ClaudeHookEntrySchema = schemas_object({
+    matcher: schemas_string().optional(),
+    hooks: schemas_array(ClaudeHookHandlerSchema).min(1, "Hook entry must include at least one handler").max(MAX_HOOKS_PER_ENTRY)
+}).strict();
+const hookEventArray = schemas_array(ClaudeHookEntrySchema);
+/**
+ * Every hook event Claude Code dispatches, each optional so that configs may
+ * use any combination.
+ *
+ * Spelled out rather than generated from a list so the schema keeps precise
+ * inferred types without a type assertion.
+ */ const claudeHookEventShape = {
+    SessionStart: hookEventArray.optional(),
+    Setup: hookEventArray.optional(),
+    UserPromptSubmit: hookEventArray.optional(),
+    UserPromptExpansion: hookEventArray.optional(),
+    PreToolUse: hookEventArray.optional(),
+    PermissionRequest: hookEventArray.optional(),
+    PermissionDenied: hookEventArray.optional(),
+    PostToolUse: hookEventArray.optional(),
+    PostToolUseFailure: hookEventArray.optional(),
+    PostToolBatch: hookEventArray.optional(),
+    Notification: hookEventArray.optional(),
+    MessageDisplay: hookEventArray.optional(),
+    SubagentStart: hookEventArray.optional(),
+    SubagentStop: hookEventArray.optional(),
+    TaskCreated: hookEventArray.optional(),
+    TaskCompleted: hookEventArray.optional(),
+    Stop: hookEventArray.optional(),
+    StopFailure: hookEventArray.optional(),
+    TeammateIdle: hookEventArray.optional(),
+    InstructionsLoaded: hookEventArray.optional(),
+    ConfigChange: hookEventArray.optional(),
+    CwdChanged: hookEventArray.optional(),
+    DirectoryAdded: hookEventArray.optional(),
+    FileChanged: hookEventArray.optional(),
+    WorktreeCreate: hookEventArray.optional(),
+    WorktreeRemove: hookEventArray.optional(),
+    PreCompact: hookEventArray.optional(),
+    PostCompact: hookEventArray.optional(),
+    Elicitation: hookEventArray.optional(),
+    ElicitationResult: hookEventArray.optional(),
+    SessionEnd: hookEventArray.optional()
+};
+/**
+ * Every known hook event name.
+ *
+ * Derived from the schema shape so the two can never drift apart, and used to
+ * report the valid set when an unknown event name is encountered.
+ */ const CLAUDE_HOOK_EVENTS = Object.keys(claudeHookEventShape);
+/**
+ * Zod schema for the hooks section of a Claude Code settings file.
+ *
+ * Every event is optional — configs may use any combination — but unknown
+ * event names are rejected so that typos surface instead of silently
+ * never firing.
+ */ const ClaudeHooksConfigSchema = schemas_object({
+    hooks: schemas_object(claudeHookEventShape).strict()
+}).passthrough();
+
 ;// CONCATENATED MODULE: ../core/src/entities/copilot-hook-schema.ts
 /**
  * Zod schemas for the GitHub Copilot hooks configuration format.
@@ -53164,7 +53353,7 @@ async function resolveConfigPathOrNull(targetDir, relativePath) {
  * depend on @lousy-agents/core.
  */ 
 const MAX_HOOKS_PER_EVENT = 100;
-/** Regex that allows standard env var names and rejects __proto__ (the prototype-polluting key). */ const ENV_KEY_PATTERN = /^(?!__proto__$)[a-zA-Z_][a-zA-Z0-9_]*$/;
+/** Regex that allows standard env var names and rejects __proto__ (the prototype-polluting key). */ const copilot_hook_schema_ENV_KEY_PATTERN = /^(?!__proto__$)[a-zA-Z_][a-zA-Z0-9_]*$/;
 /**
  * Zod schema for a single GitHub Copilot hook command entry.
  */ const CopilotHookCommandSchema = schemas_object({
@@ -53173,7 +53362,7 @@ const MAX_HOOKS_PER_EVENT = 100;
     powershell: schemas_string().min(1, "Hook PowerShell command must not be empty").optional(),
     cwd: schemas_string().optional(),
     timeoutSec: schemas_number().positive().optional(),
-    env: schemas_record(schemas_string().regex(ENV_KEY_PATTERN, "Hook env key must be a valid identifier (no prototype-polluting keys)"), schemas_string()).optional()
+    env: schemas_record(schemas_string().regex(copilot_hook_schema_ENV_KEY_PATTERN, "Hook env key must be a valid identifier (no prototype-polluting keys)"), schemas_string()).optional()
 }).strict().refine((data)=>Boolean(data.bash) || Boolean(data.powershell), {
     message: "At least one of 'bash' or 'powershell' must be provided and non-empty"
 });
@@ -53193,33 +53382,78 @@ const hookArray = schemas_array(CopilotHookCommandSchema).max(MAX_HOOKS_PER_EVEN
 }).strict();
 
 ;// CONCATENATED MODULE: ../core/src/use-cases/lint-hook-config.ts
-// biome-ignore-all lint/style/useNamingConvention: Claude Code API uses PascalCase hook event names (PreToolUse)
 /**
- * Use case for linting pre-tool-use hook configurations.
+ * Use case for linting hook configurations.
  * Validates GitHub Copilot and Claude Code hook config files.
  */ 
 
 
 const INVALID_JSON_MESSAGE_PREFIX = "Invalid JSON in hook configuration file";
+/** Joins a Zod issue path into the dotted `field` shown on a diagnostic. */ function toFieldPath(path) {
+    return path.length > 0 ? path.join(".") : undefined;
+}
 /**
- * Zod schema for a single Claude Code hook command entry.
- */ const ClaudeHookCommandSchema = schemas_object({
-    type: schemas_literal("command"),
-    command: schemas_string().min(1, "Hook command must not be empty")
-}).strict();
-/**
- * Zod schema for a single Claude Code PreToolUse hook entry.
- */ const ClaudePreToolUseEntrySchema = schemas_object({
-    matcher: schemas_string().optional(),
-    hooks: schemas_array(ClaudeHookCommandSchema).min(1)
-}).strict();
+ * Expands a single Zod issue into diagnostics.
+ *
+ * `unrecognized_keys` issues carry every offending key on one issue whose path
+ * points at the *containing* object, so they are expanded into one diagnostic
+ * per key. A stray key directly under `hooks` is a misspelled event name —
+ * the most valuable defect this linter can catch, since Claude Code silently
+ * never fires such a hook.
+ */ function toClaudeDiagnostics(issue) {
+    if (issue.code === "unrecognized_keys") {
+        const isEventName = issue.path.length === 1 && issue.path[0] === "hooks";
+        return issue.keys.map((key)=>({
+                line: 1,
+                severity: "error",
+                message: isEventName ? `Unknown hook event '${key}'. A misspelled event never fires. Valid events: ${CLAUDE_HOOK_EVENTS.join(", ")}` : `Unrecognized key: "${key}"`,
+                field: [
+                    ...issue.path,
+                    key
+                ].join("."),
+                ruleId: isEventName ? "hook/unknown-event" : "hook/invalid-config"
+            }));
+    }
+    const lastPathSegment = issue.path.at(-1);
+    const isMissingCommand = lastPathSegment === "command" && (issue.code === "too_small" || issue.code === "invalid_type");
+    return [
+        {
+            line: 1,
+            severity: "error",
+            message: issue.message,
+            field: toFieldPath([
+                ...issue.path
+            ]),
+            ruleId: isMissingCommand ? "hook/missing-command" : "hook/invalid-config"
+        }
+    ];
+}
 /**
- * Zod schema for the Claude Code hooks section within settings.
- */ const ClaudeHooksConfigSchema = schemas_object({
-    hooks: schemas_object({
-        PreToolUse: schemas_array(ClaudePreToolUseEntrySchema).min(1)
-    }).passthrough()
-}).passthrough();
+ * Warns when an entry omits `matcher` for an event that supports one.
+ *
+ * Events that accept no matcher (`Stop`, `UserPromptSubmit`, …) are skipped:
+ * an omitted matcher there is the only valid spelling, not an oversight.
+ */ function collectMissingMatcherWarnings(hooks) {
+    const diagnostics = [];
+    for (const event of CLAUDE_HOOK_EVENTS){
+        if (!MATCHER_SUPPORTING_EVENTS.has(event)) {
+            continue;
+        }
+        const entries = hooks[event] ?? [];
+        entries.forEach((entry, index)=>{
+            if (entry.matcher === undefined) {
+                diagnostics.push({
+                    line: 1,
+                    severity: "warning",
+                    message: `Recommended field 'matcher' is missing from ${event} hook entry. Without a matcher, the hook runs for every occurrence.`,
+                    field: `hooks.${event}[${index}].matcher`,
+                    ruleId: "hook/missing-matcher"
+                });
+            }
+        });
+    }
+    return diagnostics;
+}
 /**
  * Use case for linting hook configuration files across a repository.
  */ class LintHookConfigUseCase {
@@ -53321,34 +53555,11 @@ const INVALID_JSON_MESSAGE_PREFIX = "Invalid JSON in hook configuration file";
         return diagnostics;
     }
     validateClaudeConfig(parsed) {
-        const diagnostics = [];
         const result = ClaudeHooksConfigSchema.safeParse(parsed);
         if (!result.success) {
-            for (const issue of result.error.issues){
-                const lastPathSegment = issue.path.length > 0 ? issue.path[issue.path.length - 1] : undefined;
-                const isMissingCommand = lastPathSegment === "command" && (issue.code === "too_small" || issue.code === "invalid_type");
-                diagnostics.push({
-                    line: 1,
-                    severity: "error",
-                    message: issue.message,
-                    field: issue.path.length > 0 ? issue.path.join(".") : undefined,
-                    ruleId: isMissingCommand ? "hook/missing-command" : "hook/invalid-config"
-                });
-            }
-            return diagnostics;
+            return result.error.issues.flatMap((issue)=>toClaudeDiagnostics(issue));
         }
-        for (const [index, entry] of result.data.hooks.PreToolUse.entries()){
-            if (entry.matcher === undefined) {
-                diagnostics.push({
-                    line: 1,
-                    severity: "warning",
-                    message: "Recommended field 'matcher' is missing from PreToolUse hook entry. Without a matcher, the hook runs for all tools.",
-                    field: `hooks.PreToolUse[${index}].matcher`,
-                    ruleId: "hook/missing-matcher"
-                });
-            }
-        }
-        return diagnostics;
+        return collectMissingMatcherWarnings(result.data.hooks);
     }
 }
 
@@ -63711,4 +63922,4 @@ if (installedChunkData !== 0) { // 0 means "already installed".'
 // module factories are used so entry inlining is disabled
 // startup
 // Load entry module and return exports
-var __webpack_exports__ = __webpack_require__(4140);
+var __webpack_exports__ = __webpack_require__(6567);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@lousy-agents/cli",
-    "version": "5.19.0",
+    "version": "5.19.1",
     "description": "CLI scaffolding tool that sets up projects with structure, instructions, and feedback loops for AI coding assistants",
     "type": "module",
     "repository": {

package/ui/copilot-with-react/package.json

@@ -23,7 +23,7 @@
     "devDependencies": {
         "@biomejs/biome": "2.5.3",
         "@eslint/eslintrc": "3.3.6",
-        "@lousy-agents/mcp": "5.18.2",
+        "@lousy-agents/mcp": "5.19.0",
         "@modelcontextprotocol/server-sequential-thinking": "2026.7.4",
         "@testing-library/jest-dom": "7.0.0",
         "@testing-library/react": "16.3.2",