@codyswann/lisa 2.25.5 → 2.26.1

package/plugins/src/harper-fabric/skills/exploratory-qa/SKILL.md

@@ -0,0 +1,108 @@
+---
+name: exploratory-qa
+description: Playwright-backed exploratory QA workflow for web apps. Use when asked to audit an app or project with Playwright/e2e tests, find human-noticeable bugs, identify gaps in automated test coverage, test responsive breakpoints, observe slow or unclear load states, exercise mutable workflows with cleanup, or produce a QA gaps report.
+---
+
+# Exploratory QA
+
+## Overview
+
+Run a human-style exploratory QA pass informed by the existing Playwright suite. The goal is to find issues users notice and machines often miss, then translate those observations into actionable Playwright coverage gaps.
+
+## Core Workflow
+
+### 1. Establish Scope
+
+- Identify the target environment, account type, browser requirement, and requested report path.
+- If credentials, tenant, seed data, or mutation boundaries are missing and cannot be discovered safely, ask a concise clarifying question.
+- Treat production-like environments conservatively. Do not mutate production data unless the user explicitly approves it.
+- Prefer a test user, dev/staging environment, or isolated seeded account for mutation testing.
+
+### 2. Research Existing Playwright Coverage
+
+- Inspect Playwright config, auth/setup projects, fixtures, constants, selectors, test directories, skipped tests, retries, and viewport/device projects.
+- Summarize:
+  - Number and shape of specs/tests.
+  - Major workflows covered well.
+  - Skipped/flaky/TODO coverage.
+  - Viewports and browser projects used.
+  - Mutating tests and their cleanup strategy.
+  - Areas where tests assert presence instead of behavior.
+- Use existing test helpers/selectors when exploring the app. They reveal intended flows and stable hooks.
+
+### 3. Choose Browser Tools
+
+- Use the user's requested browser/tool when specified.
+- Use a real profile browser when the task depends on existing cookies, SSO, extensions, or a logged-in session.
+- Use Playwright automation when exact viewport sizing, repeatable navigation, screenshots, console logs, traces, or route timing are needed.
+- Do not let automation hide human observations. Screenshots, visible text, layout, latency, scrollability, and affordance clarity matter.
+
+### 4. Explore Like A Human
+
+Cover at least these dimensions unless the user narrows scope:
+
+- **Navigation:** direct URLs and visible click paths.
+- **Responsive behavior:** supported breakpoints, plus boundary widths where layout changes.
+- **Visual/layout quality:** cutoff text, overlap, offscreen controls, accidental horizontal scroll, empty space, awkward density, hidden stale content.
+- **Load states:** blanks, skeletons, spinners, `Loading...`, `Connecting...`, delayed hydration, and whether delays exceed a human-acceptable threshold.
+- **Behavior correctness:** sorting, filtering, saving, deleting, disabled states, permissions, tab persistence, URL canonicalization.
+- **Accessibility/testability:** hidden or off-canvas content exposed to accessibility/text locators, duplicate inactive route content, zero-sized interactive elements.
+- **Console/network health:** errors, missing assets, failed requests, noisy expected errors that could bury real failures.
+- **Data hygiene:** repeated test artifacts, stale seeded content, polluted shared accounts.
+
+## Mutation Discipline
+
+Exploratory QA should exercise mutable workflows when the environment is safe.
+
+- Prefer high-value user workflows: create/edit/delete records, lists, boards, tags, notes, comments, scenarios, uploads, messages, settings, invitations, or assignments.
+- Use unique names with a clear prefix such as `qa-`, `pw-`, or `codex-`.
+- Before mutating, identify the cleanup path. After mutating, make a best effort to clean up through the UI, then verify cleanup.
+- If UI cleanup is unavailable, record that as a product/test gap. Use documented API cleanup only if appropriate for the project and account.
+- Record all mutations performed, cleanup attempts, and residue left behind.
+- Avoid destructive bulk actions unless the user explicitly asks or the test account is clearly disposable.
+
+## Breakpoint Strategy
+
+- Discover breakpoints from the codebase, design tokens, CSS, docs, or Playwright constants when possible.
+- Test each named breakpoint and the boundary on both sides of important cutoffs.
+- If breakpoints are unknown, use a practical baseline: phone, tablet/narrow, desktop, and any app-specific cutoff discovered during research.
+- For each breakpoint, assert both user-visible behavior and automation-relevant state:
+  - Expected shell/navigation variant.
+  - Route-specific loaded content.
+  - Critical controls visible and reachable.
+  - No unintended document-level horizontal overflow.
+  - Intentional scroll containers remain usable.
+  - Hidden/off-canvas UI is not exposed as active content.
+
+## Load-State Strategy
+
+Measure perceived latency, not just eventual success.
+
+- Track time to shell, time to meaningful route content, and time spent in blank/loading/spinner/connecting states.
+- Note when a page is technically interactive but still visually incomplete.
+- Treat long waits without clear progress, error, retry, or cancellation as bugs or test gaps.
+- Do not overfit exact milliseconds unless the project has defined budgets. Use practical labels such as noticeable, slow, or unacceptable and include observed durations when available.
+
+## Report Structure
+
+Write the report to the user's requested path. If none is specified, use a clear local name such as `PLAYWRIGHT_GAPS.md` or `EXPLORATORY_QA_REPORT.md`.
+
+Include:
+
+- Scope: target URL/env, browser/tool, account type, build/version if visible, date.
+- Existing Playwright coverage: strengths, thin areas, skipped tests, viewport/browser matrix, mutation coverage.
+- Exploratory findings: steps, observed behavior, impact, why existing tests miss it, recommended test.
+- Breakpoint findings: exact viewports tested and boundary behavior.
+- Load-state findings: observed delays, blank/spinner/connecting states, suggested budgets/tests.
+- Mutation findings: data created, behavior observed, cleanup attempt, cleanup result, residue.
+- Missing Playwright tests to add: prioritized, concrete, and automatable.
+- Maintenance notes: selector scoping, fixture cleanup, flaky/stale-state risks.
+
+## Quality Bar
+
+- Be honest about what was and was not tested.
+- Distinguish user-visible bugs from missing automated coverage.
+- Prefer concrete examples over vague recommendations.
+- Do not claim cleanup succeeded unless verified.
+- Do not let broad locators pass against hidden/inactive content.
+- Preserve unrelated repo changes and keep report edits scoped.

package/plugins/src/rails/commands/exploratory-qa.md

@@ -0,0 +1,7 @@
+---
+description: "Run a Playwright-backed exploratory QA pass: audit the app like a human, find user-noticeable bugs and gaps in automated test coverage, and produce a QA gaps report."
+allowed-tools: ["Skill"]
+argument-hint: "[target-url | env] [report-path]"
+---
+
+Use the /lisa-rails:exploratory-qa skill to run a human-style exploratory QA pass informed by the existing Playwright suite, then produce an actionable coverage-gaps report. $ARGUMENTS

package/plugins/src/rails/skills/exploratory-qa/SKILL.md

@@ -0,0 +1,108 @@
+---
+name: exploratory-qa
+description: Playwright-backed exploratory QA workflow for web apps. Use when asked to audit an app or project with Playwright/e2e tests, find human-noticeable bugs, identify gaps in automated test coverage, test responsive breakpoints, observe slow or unclear load states, exercise mutable workflows with cleanup, or produce a QA gaps report.
+---
+
+# Exploratory QA
+
+## Overview
+
+Run a human-style exploratory QA pass informed by the existing Playwright suite. The goal is to find issues users notice and machines often miss, then translate those observations into actionable Playwright coverage gaps.
+
+## Core Workflow
+
+### 1. Establish Scope
+
+- Identify the target environment, account type, browser requirement, and requested report path.
+- If credentials, tenant, seed data, or mutation boundaries are missing and cannot be discovered safely, ask a concise clarifying question.
+- Treat production-like environments conservatively. Do not mutate production data unless the user explicitly approves it.
+- Prefer a test user, dev/staging environment, or isolated seeded account for mutation testing.
+
+### 2. Research Existing Playwright Coverage
+
+- Inspect Playwright config, auth/setup projects, fixtures, constants, selectors, test directories, skipped tests, retries, and viewport/device projects.
+- Summarize:
+  - Number and shape of specs/tests.
+  - Major workflows covered well.
+  - Skipped/flaky/TODO coverage.
+  - Viewports and browser projects used.
+  - Mutating tests and their cleanup strategy.
+  - Areas where tests assert presence instead of behavior.
+- Use existing test helpers/selectors when exploring the app. They reveal intended flows and stable hooks.
+
+### 3. Choose Browser Tools
+
+- Use the user's requested browser/tool when specified.
+- Use a real profile browser when the task depends on existing cookies, SSO, extensions, or a logged-in session.
+- Use Playwright automation when exact viewport sizing, repeatable navigation, screenshots, console logs, traces, or route timing are needed.
+- Do not let automation hide human observations. Screenshots, visible text, layout, latency, scrollability, and affordance clarity matter.
+
+### 4. Explore Like A Human
+
+Cover at least these dimensions unless the user narrows scope:
+
+- **Navigation:** direct URLs and visible click paths.
+- **Responsive behavior:** supported breakpoints, plus boundary widths where layout changes.
+- **Visual/layout quality:** cutoff text, overlap, offscreen controls, accidental horizontal scroll, empty space, awkward density, hidden stale content.
+- **Load states:** blanks, skeletons, spinners, `Loading...`, `Connecting...`, delayed hydration, and whether delays exceed a human-acceptable threshold.
+- **Behavior correctness:** sorting, filtering, saving, deleting, disabled states, permissions, tab persistence, URL canonicalization.
+- **Accessibility/testability:** hidden or off-canvas content exposed to accessibility/text locators, duplicate inactive route content, zero-sized interactive elements.
+- **Console/network health:** errors, missing assets, failed requests, noisy expected errors that could bury real failures.
+- **Data hygiene:** repeated test artifacts, stale seeded content, polluted shared accounts.
+
+## Mutation Discipline
+
+Exploratory QA should exercise mutable workflows when the environment is safe.
+
+- Prefer high-value user workflows: create/edit/delete records, lists, boards, tags, notes, comments, scenarios, uploads, messages, settings, invitations, or assignments.
+- Use unique names with a clear prefix such as `qa-`, `pw-`, or `codex-`.
+- Before mutating, identify the cleanup path. After mutating, make a best effort to clean up through the UI, then verify cleanup.
+- If UI cleanup is unavailable, record that as a product/test gap. Use documented API cleanup only if appropriate for the project and account.
+- Record all mutations performed, cleanup attempts, and residue left behind.
+- Avoid destructive bulk actions unless the user explicitly asks or the test account is clearly disposable.
+
+## Breakpoint Strategy
+
+- Discover breakpoints from the codebase, design tokens, CSS, docs, or Playwright constants when possible.
+- Test each named breakpoint and the boundary on both sides of important cutoffs.
+- If breakpoints are unknown, use a practical baseline: phone, tablet/narrow, desktop, and any app-specific cutoff discovered during research.
+- For each breakpoint, assert both user-visible behavior and automation-relevant state:
+  - Expected shell/navigation variant.
+  - Route-specific loaded content.
+  - Critical controls visible and reachable.
+  - No unintended document-level horizontal overflow.
+  - Intentional scroll containers remain usable.
+  - Hidden/off-canvas UI is not exposed as active content.
+
+## Load-State Strategy
+
+Measure perceived latency, not just eventual success.
+
+- Track time to shell, time to meaningful route content, and time spent in blank/loading/spinner/connecting states.
+- Note when a page is technically interactive but still visually incomplete.
+- Treat long waits without clear progress, error, retry, or cancellation as bugs or test gaps.
+- Do not overfit exact milliseconds unless the project has defined budgets. Use practical labels such as noticeable, slow, or unacceptable and include observed durations when available.
+
+## Report Structure
+
+Write the report to the user's requested path. If none is specified, use a clear local name such as `PLAYWRIGHT_GAPS.md` or `EXPLORATORY_QA_REPORT.md`.
+
+Include:
+
+- Scope: target URL/env, browser/tool, account type, build/version if visible, date.
+- Existing Playwright coverage: strengths, thin areas, skipped tests, viewport/browser matrix, mutation coverage.
+- Exploratory findings: steps, observed behavior, impact, why existing tests miss it, recommended test.
+- Breakpoint findings: exact viewports tested and boundary behavior.
+- Load-state findings: observed delays, blank/spinner/connecting states, suggested budgets/tests.
+- Mutation findings: data created, behavior observed, cleanup attempt, cleanup result, residue.
+- Missing Playwright tests to add: prioritized, concrete, and automatable.
+- Maintenance notes: selector scoping, fixture cleanup, flaky/stale-state risks.
+
+## Quality Bar
+
+- Be honest about what was and was not tested.
+- Distinguish user-visible bugs from missing automated coverage.
+- Prefer concrete examples over vague recommendations.
+- Do not claim cleanup succeeded unless verified.
+- Do not let broad locators pass against hidden/inactive content.
+- Preserve unrelated repo changes and keep report edits scoped.

package/scripts/generate-codex-plugin-artifacts.mjs

@@ -2,9 +2,19 @@
 /**
  * Generate Codex plugin artifacts from the built Claude plugin directories.
  *
- * Claude remains Lisa's production path; this script makes the Codex side
- * durable by deriving .codex-plugin metadata and compatible hook manifests
- * every time plugins are rebuilt.
+ * Claude remains Lisa's production path; this script derives the .codex-plugin
+ * metadata (skills + MCP pointers) every time plugins are rebuilt.
+ *
+ * NOTE ON HOOKS: this script does NOT emit Codex hooks. Codex (codex-cli
+ * 0.125.0) does not execute plugin-bundled hooks — its plugin manifest parser
+ * only honors `skills`, `mcpServers`, `apps`, and interface fields, and a
+ * runtime test confirmed a bundled `hooks/hooks.json` never fires. Lisa's
+ * Codex hooks are instead installed into the project's `.codex/hooks.json`
+ * by `src/codex/hooks-installer.ts` (run during `lisa` apply). Hooks with no
+ * Codex equivalent are intentionally not ported: `enforce-team-first.sh`
+ * (Claude-team-specific), `inject-flow-context.sh` and any SubagentStart hook
+ * (Codex has no SubagentStart event), and the SessionEnd `entire` hook (Codex
+ * has no SessionEnd event).
  */
 import fs from "node:fs";
 import path from "node:path";
@@ -29,17 +39,10 @@ if (!fs.existsSync(claudeManifestPath)) {
 
 const claudeManifest = JSON.parse(fs.readFileSync(claudeManifestPath, "utf8"));
 const pluginName = claudeManifest.name;
-const UNSUPPORTED_CODEX_HOOK_SCRIPTS = new Set([
-  "hooks/enforce-team-first.sh",
-  "hooks/inject-flow-context.sh",
-  "hooks/inject-rules.sh",
-]);
-const codexHooks = convertHooks(pluginName, claudeManifest.hooks ?? {});
 
-writeCodexManifest(pluginName, versionArg, codexHooks);
-writeCodexHooks(codexHooks);
+writeCodexManifest(pluginName, versionArg);
 
-function writeCodexManifest(pluginName, version, hooksFile) {
+function writeCodexManifest(pluginName, version) {
   const metadata = metadataFor(pluginName);
   const manifest = {
     name: pluginName,
@@ -50,7 +53,7 @@ function writeCodexManifest(pluginName, version, hooksFile) {
     ...(claudeManifest.dependencies
       ? { dependencies: claudeManifest.dependencies }
       : {}),
-    ...componentPointers(hooksFile),
+    ...componentPointers(),
     interface: {
       displayName: metadata.displayName,
       shortDescription: metadata.shortDescription,
@@ -70,7 +73,7 @@ function writeCodexManifest(pluginName, version, hooksFile) {
   );
 }
 
-function componentPointers(hooksFile) {
+function componentPointers() {
   return {
     ...(fs.existsSync(path.join(pluginDir, "skills"))
       ? { skills: "./skills/" }
@@ -78,124 +81,9 @@ function componentPointers(hooksFile) {
     ...(fs.existsSync(path.join(pluginDir, ".mcp.json"))
       ? { mcpServers: "./.mcp.json" }
       : {}),
-    ...(hooksFile ? { hooks: "./hooks/hooks.json" } : {}),
   };
 }
 
-function writeCodexHooks(hooksFile) {
-  const hooksDir = path.join(pluginDir, "hooks");
-  const hooksPath = path.join(hooksDir, "hooks.json");
-  if (!hooksFile) {
-    if (fs.existsSync(hooksPath)) {
-      fs.rmSync(hooksPath);
-    }
-    return;
-  }
-  fs.mkdirSync(hooksDir, { recursive: true });
-  fs.writeFileSync(hooksPath, `${JSON.stringify(hooksFile, null, 2)}\n`);
-}
-
-function convertHooks(pluginName, claudeHooks) {
-  const supportedEvents = new Set([
-    "UserPromptSubmit",
-    "PostToolUse",
-    "PreToolUse",
-    "Stop",
-    "SessionStart",
-  ]);
-  const entries = Object.entries(claudeHooks)
-    .filter(([event]) => supportedEvents.has(event))
-    .map(([event, groups]) => [event, convertHookGroups(pluginName, groups)])
-    .filter(([, groups]) => groups.length > 0);
-  return entries.length > 0
-    ? { hooks: Object.fromEntries(entries) }
-    : undefined;
-}
-
-function convertHookGroups(pluginName, groups) {
-  return groups
-    .map(group => ({
-      ...(group.matcher !== undefined
-        ? { matcher: normalizeMatcher(group.matcher) }
-        : {}),
-      hooks: (group.hooks ?? [])
-        .map(hook => convertHookHandler(pluginName, hook))
-        .filter(Boolean),
-    }))
-    .filter(group => group.hooks.length > 0);
-}
-
-function normalizeMatcher(matcher) {
-  const normalized = String(matcher).replaceAll("Write|Edit", "Edit|Write");
-  return normalized.includes("apply_patch")
-    ? normalized
-    : normalized.replaceAll("Edit|Write", "Edit|Write|apply_patch");
-}
-
-function convertHookHandler(pluginName, hook) {
-  if (hook.type !== "command" || typeof hook.command !== "string") {
-    return undefined;
-  }
-  const command = convertHookCommand(pluginName, hook.command);
-  if (command === undefined) {
-    return undefined;
-  }
-  return {
-    type: "command",
-    command,
-    ...(hook.timeout !== undefined ? { timeout: hook.timeout } : {}),
-    ...(hook.statusMessage !== undefined
-      ? { statusMessage: hook.statusMessage }
-      : {}),
-  };
-}
-
-function convertHookCommand(pluginName, command) {
-  const pluginScript = command.match(
-    /\$\{CLAUDE_PLUGIN_ROOT\}\/(hooks\/[^ "';]+)/
-  );
-  if (!pluginScript) {
-    return normalizeInlineCommand(command);
-  }
-  if (UNSUPPORTED_CODEX_HOOK_SCRIPTS.has(pluginScript[1])) {
-    return undefined;
-  }
-  return buildPluginScriptRunner(pluginName, pluginScript[1]);
-}
-
-function normalizeInlineCommand(command) {
-  const entireMatch = command.match(
-    /^command -v entire >\/dev\/null 2>&1 && entire hooks claude-code ([a-z-]+) \|\| true$/
-  );
-  if (!entireMatch) {
-    return command;
-  }
-  return `if command -v entire >/dev/null 2>&1; then entire hooks claude-code ${entireMatch[1]}; fi`;
-}
-
-function buildPluginScriptRunner(pluginName, scriptPath) {
-  const script = JSON.stringify(scriptPath);
-  const plugin = JSON.stringify(pluginName);
-  return [
-    "bash -lc '",
-    `plugin=${shellQuote(plugin)}; script=${shellQuote(script)}; `,
-    "repo=$(git rev-parse --show-toplevel 2>/dev/null || pwd); ",
-    'for root in "${CODEX_PLUGIN_ROOT:-}" "${CLAUDE_PLUGIN_ROOT:-}" "$repo/plugins/$plugin" "$HOME/.codex/plugins/cache/lisa/$plugin/local"; do ',
-    '[ -n "$root" ] || continue; ',
-    'if [ -x "$root/$script" ]; then CLAUDE_PLUGIN_ROOT="$root" CODEX_PLUGIN_ROOT="$root" exec "$root/$script"; fi; ',
-    "done; ",
-    'found=$(find "$HOME/.codex/plugins/cache" -path "*/$plugin/*/$script" -type f -exec ls -t {} + 2>/dev/null | head -n 1); ',
-    '[ -n "$found" ] || exit 0; ',
-    "root=${found%/$script}; ",
-    'CLAUDE_PLUGIN_ROOT="$root" CODEX_PLUGIN_ROOT="$root" exec "$found"',
-    "'",
-  ].join("");
-}
-
-function shellQuote(jsonStringLiteral) {
-  return jsonStringLiteral.replaceAll("'", "'\\''");
-}
-
 function metadataFor(pluginName) {
   const map = {
     lisa: {

package/plugins/lisa/hooks/hooks.json

@@ -1,104 +0,0 @@
-{
-  "hooks": {
-    "UserPromptSubmit": [
-      {
-        "matcher": "",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "if command -v entire >/dev/null 2>&1; then entire hooks claude-code user-prompt-submit; fi"
-          }
-        ]
-      }
-    ],
-    "PostToolUse": [
-      {
-        "matcher": "Task",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "if command -v entire >/dev/null 2>&1; then entire hooks claude-code post-task; fi"
-          }
-        ]
-      },
-      {
-        "matcher": "TodoWrite",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "if command -v entire >/dev/null 2>&1; then entire hooks claude-code post-todo; fi"
-          }
-        ]
-      }
-    ],
-    "PreToolUse": [
-      {
-        "matcher": "Task",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "if command -v entire >/dev/null 2>&1; then entire hooks claude-code pre-task; fi"
-          }
-        ]
-      },
-      {
-        "matcher": "Bash",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "bash -lc 'plugin=\"lisa\"; script=\"hooks/block-no-verify.sh\"; repo=$(git rev-parse --show-toplevel 2>/dev/null || pwd); for root in \"${CODEX_PLUGIN_ROOT:-}\" \"${CLAUDE_PLUGIN_ROOT:-}\" \"$repo/plugins/$plugin\" \"$HOME/.codex/plugins/cache/lisa/$plugin/local\"; do [ -n \"$root\" ] || continue; if [ -x \"$root/$script\" ]; then CLAUDE_PLUGIN_ROOT=\"$root\" CODEX_PLUGIN_ROOT=\"$root\" exec \"$root/$script\"; fi; done; found=$(find \"$HOME/.codex/plugins/cache\" -path \"*/$plugin/*/$script\" -type f -exec ls -t {} + 2>/dev/null | head -n 1); [ -n \"$found\" ] || exit 0; root=${found%/$script}; CLAUDE_PLUGIN_ROOT=\"$root\" CODEX_PLUGIN_ROOT=\"$root\" exec \"$found\"'"
-          }
-        ]
-      }
-    ],
-    "Stop": [
-      {
-        "matcher": "",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "bash -lc 'plugin=\"lisa\"; script=\"hooks/notify-ntfy.sh\"; repo=$(git rev-parse --show-toplevel 2>/dev/null || pwd); for root in \"${CODEX_PLUGIN_ROOT:-}\" \"${CLAUDE_PLUGIN_ROOT:-}\" \"$repo/plugins/$plugin\" \"$HOME/.codex/plugins/cache/lisa/$plugin/local\"; do [ -n \"$root\" ] || continue; if [ -x \"$root/$script\" ]; then CLAUDE_PLUGIN_ROOT=\"$root\" CODEX_PLUGIN_ROOT=\"$root\" exec \"$root/$script\"; fi; done; found=$(find \"$HOME/.codex/plugins/cache\" -path \"*/$plugin/*/$script\" -type f -exec ls -t {} + 2>/dev/null | head -n 1); [ -n \"$found\" ] || exit 0; root=${found%/$script}; CLAUDE_PLUGIN_ROOT=\"$root\" CODEX_PLUGIN_ROOT=\"$root\" exec \"$found\"'"
-          }
-        ]
-      },
-      {
-        "matcher": "",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "if command -v entire >/dev/null 2>&1; then entire hooks claude-code stop; fi"
-          }
-        ]
-      }
-    ],
-    "SessionStart": [
-      {
-        "matcher": "startup",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "bash -lc 'plugin=\"lisa\"; script=\"hooks/install-pkgs.sh\"; repo=$(git rev-parse --show-toplevel 2>/dev/null || pwd); for root in \"${CODEX_PLUGIN_ROOT:-}\" \"${CLAUDE_PLUGIN_ROOT:-}\" \"$repo/plugins/$plugin\" \"$HOME/.codex/plugins/cache/lisa/$plugin/local\"; do [ -n \"$root\" ] || continue; if [ -x \"$root/$script\" ]; then CLAUDE_PLUGIN_ROOT=\"$root\" CODEX_PLUGIN_ROOT=\"$root\" exec \"$root/$script\"; fi; done; found=$(find \"$HOME/.codex/plugins/cache\" -path \"*/$plugin/*/$script\" -type f -exec ls -t {} + 2>/dev/null | head -n 1); [ -n \"$found\" ] || exit 0; root=${found%/$script}; CLAUDE_PLUGIN_ROOT=\"$root\" CODEX_PLUGIN_ROOT=\"$root\" exec \"$found\"'"
-          }
-        ]
-      },
-      {
-        "matcher": "",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "bash -lc 'plugin=\"lisa\"; script=\"hooks/setup-jira-cli.sh\"; repo=$(git rev-parse --show-toplevel 2>/dev/null || pwd); for root in \"${CODEX_PLUGIN_ROOT:-}\" \"${CLAUDE_PLUGIN_ROOT:-}\" \"$repo/plugins/$plugin\" \"$HOME/.codex/plugins/cache/lisa/$plugin/local\"; do [ -n \"$root\" ] || continue; if [ -x \"$root/$script\" ]; then CLAUDE_PLUGIN_ROOT=\"$root\" CODEX_PLUGIN_ROOT=\"$root\" exec \"$root/$script\"; fi; done; found=$(find \"$HOME/.codex/plugins/cache\" -path \"*/$plugin/*/$script\" -type f -exec ls -t {} + 2>/dev/null | head -n 1); [ -n \"$found\" ] || exit 0; root=${found%/$script}; CLAUDE_PLUGIN_ROOT=\"$root\" CODEX_PLUGIN_ROOT=\"$root\" exec \"$found\"'"
-          }
-        ]
-      },
-      {
-        "matcher": "",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "if command -v entire >/dev/null 2>&1; then entire hooks claude-code session-start; fi"
-          }
-        ]
-      }
-    ]
-  }
-}

package/plugins/lisa-nestjs/hooks/hooks.json

@@ -1,15 +0,0 @@
-{
-  "hooks": {
-    "PreToolUse": [
-      {
-        "matcher": "Edit|Write|apply_patch",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "bash -lc 'plugin=\"lisa-nestjs\"; script=\"hooks/block-migration-edits.sh\"; repo=$(git rev-parse --show-toplevel 2>/dev/null || pwd); for root in \"${CODEX_PLUGIN_ROOT:-}\" \"${CLAUDE_PLUGIN_ROOT:-}\" \"$repo/plugins/$plugin\" \"$HOME/.codex/plugins/cache/lisa/$plugin/local\"; do [ -n \"$root\" ] || continue; if [ -x \"$root/$script\" ]; then CLAUDE_PLUGIN_ROOT=\"$root\" CODEX_PLUGIN_ROOT=\"$root\" exec \"$root/$script\"; fi; done; found=$(find \"$HOME/.codex/plugins/cache\" -path \"*/$plugin/*/$script\" -type f -exec ls -t {} + 2>/dev/null | head -n 1); [ -n \"$found\" ] || exit 0; root=${found%/$script}; CLAUDE_PLUGIN_ROOT=\"$root\" CODEX_PLUGIN_ROOT=\"$root\" exec \"$found\"'"
-          }
-        ]
-      }
-    ]
-  }
-}

package/plugins/lisa-rails/hooks/hooks.json

@@ -1,19 +0,0 @@
-{
-  "hooks": {
-    "PostToolUse": [
-      {
-        "matcher": "Edit|Write|apply_patch",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "bash -lc 'plugin=\"lisa-rails\"; script=\"hooks/rubocop-on-edit.sh\"; repo=$(git rev-parse --show-toplevel 2>/dev/null || pwd); for root in \"${CODEX_PLUGIN_ROOT:-}\" \"${CLAUDE_PLUGIN_ROOT:-}\" \"$repo/plugins/$plugin\" \"$HOME/.codex/plugins/cache/lisa/$plugin/local\"; do [ -n \"$root\" ] || continue; if [ -x \"$root/$script\" ]; then CLAUDE_PLUGIN_ROOT=\"$root\" CODEX_PLUGIN_ROOT=\"$root\" exec \"$root/$script\"; fi; done; found=$(find \"$HOME/.codex/plugins/cache\" -path \"*/$plugin/*/$script\" -type f -exec ls -t {} + 2>/dev/null | head -n 1); [ -n \"$found\" ] || exit 0; root=${found%/$script}; CLAUDE_PLUGIN_ROOT=\"$root\" CODEX_PLUGIN_ROOT=\"$root\" exec \"$found\"'"
-          },
-          {
-            "type": "command",
-            "command": "bash -lc 'plugin=\"lisa-rails\"; script=\"hooks/sg-scan-on-edit.sh\"; repo=$(git rev-parse --show-toplevel 2>/dev/null || pwd); for root in \"${CODEX_PLUGIN_ROOT:-}\" \"${CLAUDE_PLUGIN_ROOT:-}\" \"$repo/plugins/$plugin\" \"$HOME/.codex/plugins/cache/lisa/$plugin/local\"; do [ -n \"$root\" ] || continue; if [ -x \"$root/$script\" ]; then CLAUDE_PLUGIN_ROOT=\"$root\" CODEX_PLUGIN_ROOT=\"$root\" exec \"$root/$script\"; fi; done; found=$(find \"$HOME/.codex/plugins/cache\" -path \"*/$plugin/*/$script\" -type f -exec ls -t {} + 2>/dev/null | head -n 1); [ -n \"$found\" ] || exit 0; root=${found%/$script}; CLAUDE_PLUGIN_ROOT=\"$root\" CODEX_PLUGIN_ROOT=\"$root\" exec \"$found\"'"
-          }
-        ]
-      }
-    ]
-  }
-}

package/plugins/lisa-typescript/hooks/hooks.json

@@ -1,23 +0,0 @@
-{
-  "hooks": {
-    "PostToolUse": [
-      {
-        "matcher": "Edit|Write|apply_patch",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "bash -lc 'plugin=\"lisa-typescript\"; script=\"hooks/format-on-edit.sh\"; repo=$(git rev-parse --show-toplevel 2>/dev/null || pwd); for root in \"${CODEX_PLUGIN_ROOT:-}\" \"${CLAUDE_PLUGIN_ROOT:-}\" \"$repo/plugins/$plugin\" \"$HOME/.codex/plugins/cache/lisa/$plugin/local\"; do [ -n \"$root\" ] || continue; if [ -x \"$root/$script\" ]; then CLAUDE_PLUGIN_ROOT=\"$root\" CODEX_PLUGIN_ROOT=\"$root\" exec \"$root/$script\"; fi; done; found=$(find \"$HOME/.codex/plugins/cache\" -path \"*/$plugin/*/$script\" -type f -exec ls -t {} + 2>/dev/null | head -n 1); [ -n \"$found\" ] || exit 0; root=${found%/$script}; CLAUDE_PLUGIN_ROOT=\"$root\" CODEX_PLUGIN_ROOT=\"$root\" exec \"$found\"'"
-          },
-          {
-            "type": "command",
-            "command": "bash -lc 'plugin=\"lisa-typescript\"; script=\"hooks/sg-scan-on-edit.sh\"; repo=$(git rev-parse --show-toplevel 2>/dev/null || pwd); for root in \"${CODEX_PLUGIN_ROOT:-}\" \"${CLAUDE_PLUGIN_ROOT:-}\" \"$repo/plugins/$plugin\" \"$HOME/.codex/plugins/cache/lisa/$plugin/local\"; do [ -n \"$root\" ] || continue; if [ -x \"$root/$script\" ]; then CLAUDE_PLUGIN_ROOT=\"$root\" CODEX_PLUGIN_ROOT=\"$root\" exec \"$root/$script\"; fi; done; found=$(find \"$HOME/.codex/plugins/cache\" -path \"*/$plugin/*/$script\" -type f -exec ls -t {} + 2>/dev/null | head -n 1); [ -n \"$found\" ] || exit 0; root=${found%/$script}; CLAUDE_PLUGIN_ROOT=\"$root\" CODEX_PLUGIN_ROOT=\"$root\" exec \"$found\"'"
-          },
-          {
-            "type": "command",
-            "command": "bash -lc 'plugin=\"lisa-typescript\"; script=\"hooks/lint-on-edit.sh\"; repo=$(git rev-parse --show-toplevel 2>/dev/null || pwd); for root in \"${CODEX_PLUGIN_ROOT:-}\" \"${CLAUDE_PLUGIN_ROOT:-}\" \"$repo/plugins/$plugin\" \"$HOME/.codex/plugins/cache/lisa/$plugin/local\"; do [ -n \"$root\" ] || continue; if [ -x \"$root/$script\" ]; then CLAUDE_PLUGIN_ROOT=\"$root\" CODEX_PLUGIN_ROOT=\"$root\" exec \"$root/$script\"; fi; done; found=$(find \"$HOME/.codex/plugins/cache\" -path \"*/$plugin/*/$script\" -type f -exec ls -t {} + 2>/dev/null | head -n 1); [ -n \"$found\" ] || exit 0; root=${found%/$script}; CLAUDE_PLUGIN_ROOT=\"$root\" CODEX_PLUGIN_ROOT=\"$root\" exec \"$found\"'"
-          }
-        ]
-      }
-    ]
-  }
-}