@laitszkin/apollo-toolkit 2.11.2 → 2.11.4

package/open-github-issue/tests/test_open_github_issue.py

@@ -81,6 +81,11 @@ class OpenGitHubIssueTests(unittest.TestCase):
             proposal="Allow exporting incident timelines",
             reason="Support postmortem handoff",
             suggested_architecture="Add shared exporters and UI action",
+            impact=None,
+            evidence=None,
+            suggested_action=None,
+            severity=None,
+            affected_scope=None,
         )
 
         self.assertIn("### 功能提案", zh_body)
@@ -88,6 +93,28 @@ class OpenGitHubIssueTests(unittest.TestCase):
         self.assertIn("### Feature Proposal", en_body)
         self.assertIn("### Suggested Architecture", en_body)
 
+    def test_build_issue_body_supports_security_issue_sections(self) -> None:
+        en_body = MODULE.build_issue_body(
+            issue_type=MODULE.ISSUE_TYPE_SECURITY,
+            language="en",
+            title="[Security] Missing auth",
+            problem_description="Endpoint misses admin check",
+            suspected_cause=None,
+            reproduction=None,
+            proposal=None,
+            reason=None,
+            suggested_architecture=None,
+            impact="Sensitive export may leak",
+            evidence="Reproduced request and code path review",
+            suggested_action="Add authz and tests",
+            severity="high",
+            affected_scope="/admin/export",
+        )
+
+        self.assertIn("### Security Risk", en_body)
+        self.assertIn("### Severity", en_body)
+        self.assertIn("### Suggested Mitigation", en_body)
+
     def test_validate_issue_content_args_requires_feature_fields(self) -> None:
         with self.assertRaises(SystemExit):
             MODULE.validate_issue_content_args(
@@ -118,6 +145,43 @@ class OpenGitHubIssueTests(unittest.TestCase):
                 suggested_architecture="shared module",
                 problem_description=None,
                 suspected_cause=None,
+                impact=None,
+                evidence=None,
+                suggested_action=None,
+                severity=None,
+                affected_scope=None,
+            )
+        )
+
+    def test_validate_issue_content_args_requires_security_fields(self) -> None:
+        with self.assertRaises(SystemExit):
+            MODULE.validate_issue_content_args(
+                Namespace(
+                    issue_type=MODULE.ISSUE_TYPE_SECURITY,
+                    problem_description="auth missing",
+                    affected_scope="",
+                    impact="sensitive export may leak",
+                    evidence="reproduced",
+                    suggested_action="add authz",
+                    severity="high",
+                    reason=None,
+                    suggested_architecture=None,
+                    suspected_cause=None,
+                )
+            )
+
+        MODULE.validate_issue_content_args(
+            Namespace(
+                issue_type=MODULE.ISSUE_TYPE_SECURITY,
+                problem_description="auth missing",
+                affected_scope="/admin/export",
+                impact="sensitive export may leak",
+                evidence="reproduced",
+                suggested_action="add authz",
+                severity="high",
+                reason=None,
+                suggested_architecture=None,
+                suspected_cause=None,
             )
         )
 
@@ -130,6 +194,11 @@ class OpenGitHubIssueTests(unittest.TestCase):
                     suggested_architecture=None,
                     problem_description="Repeated timeout warnings escalated into request failures.",
                     suspected_cause="handler.py:12",
+                    impact=None,
+                    evidence=None,
+                    suggested_action=None,
+                    severity=None,
+                    affected_scope=None,
                 )
             )
 
@@ -153,6 +222,11 @@ class OpenGitHubIssueTests(unittest.TestCase):
                     "- Difference/Impact: users still receive errors.\n"
                 ),
                 suspected_cause="handler.py:12",
+                impact=None,
+                evidence=None,
+                suggested_action=None,
+                severity=None,
+                affected_scope=None,
             )
         )
 
@@ -181,6 +255,11 @@ class OpenGitHubIssueTests(unittest.TestCase):
             suggested_architecture=None,
             repo="owner/repo",
             dry_run=True,
+            impact=None,
+            evidence=None,
+            suggested_action=None,
+            severity=None,
+            affected_scope=None,
         )
 
         with patch.object(MODULE, "parse_args", return_value=args), patch.object(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@laitszkin/apollo-toolkit",
-  "version": "2.11.2",
+  "version": "2.11.4",
   "description": "Apollo Toolkit npm installer for managed skill copying across Codex, OpenClaw, and Trae.",
   "license": "MIT",
   "author": "LaiTszKin",

package/production-sim-debug/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 LaiTszKin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/production-sim-debug/README.md

@@ -0,0 +1,91 @@
+# Production Sim Debug
+
+An agent skill for investigating production or local simulation runs when the observed behavior diverges from the intended market scenario or expected liquidation/remediation outcomes.
+
+This skill helps agents reproduce a bounded simulation run, inspect the real preset and runtime artifacts, separate product bugs from local harness drift, and apply the smallest realistic fix before rerunning the same scenario.
+
+## What this skill provides
+
+- A workflow for bounded production/local simulation diagnosis.
+- A decision tree for separating runtime logic bugs from harness, stub, preset, and persistence issues.
+- A repeatable way to audit the active run directory, logs, and event database before drawing conclusions.
+- Guidance for turning recurring ad hoc scenarios into named presets and documented test cases.
+- Emphasis on rerunning the same scenario after a fix instead of relying only on unit tests.
+
+## Repository structure
+
+- `SKILL.md`: Main skill definition, workflow, and output contract.
+- `agents/openai.yaml`: Agent interface metadata and default prompt.
+
+## Installation
+
+1. Clone this repository.
+2. Copy this folder to your Codex skills directory:
+
+```bash
+mkdir -p "$CODEX_HOME/skills"
+cp -R production-sim-debug "$CODEX_HOME/skills/production-sim-debug"
+```
+
+## Usage
+
+Invoke the skill in your prompt:
+
+```text
+Use $production-sim-debug to run this repository's production local simulation with the named preset for 5 minutes, explain why remediations or liquidations did not land, and fix any harness or runtime-alignment issues you confirm.
+```
+
+Best results come from including:
+
+- workspace path
+- canonical simulation entrypoint
+- preset or scenario name
+- run duration
+- expected market shape or success criteria
+- the run directory to inspect, if it already exists
+- whether toolchain fixes are in scope or the task is read-only
+
+If the repository already has a named preset system, prefer using it instead of describing the scenario only in prose.
+
+## Example
+
+### Input prompt
+
+```text
+Use $production-sim-debug for this repository.
+
+Workspace: /workspace/pangu
+Entrypoint: ./scripts/run-production-local-sim.sh stress-test-1
+Duration: 5 minutes
+Expectations:
+- Jupiter free tier
+- mostly oracle-blocked positions that can be unlocked by remediation
+- some directly executable opportunities
+- evidence-backed explanation for why liquidations did or did not land
+```
+
+### Expected response shape
+
+```text
+1) Scenario contract
+- Named preset, duration, and run directory used.
+
+2) Observed outcomes
+- Event-table counts, dominant skip reasons, and runtime stage reached.
+
+3) Root cause
+- Whether the main blocker was product logic, quote budget, preset design, or harness/stub drift.
+
+4) Fixes applied
+- Toolchain or runtime fixes with file paths.
+
+5) Validation
+- Rerun or targeted tests proving the intended stage now executes.
+
+6) Remaining gaps
+- Any realism differences still left between local simulation and chain behavior.
+```
+
+## License
+
+MIT. See `LICENSE`.

package/production-sim-debug/SKILL.md

@@ -0,0 +1,131 @@
+---
+name: production-sim-debug
+description: Investigate production or local simulation runs for runtime-toolchain drift, harness bugs, preset mistakes, unrealistic local stubs, or mismatches between expected and observed liquidation outcomes. Use when users ask to run bounded production simulations, explain why simulated liquidations or remediations did not happen, calibrate presets, or fix local simulation tooling so it better matches real on-chain behavior.
+---
+
+# Production Sim Debug
+
+## Dependencies
+
+- Required: `systematic-debug` for evidence-first root-cause analysis when a simulation shows failing or missing expected behavior.
+- Conditional: `scheduled-runtime-health-check` when the user wants a bounded production/local simulation run executed and observed; `read-github-issue` when the requested simulation work is driven by a remote issue; `open-github-issue` when confirmed toolchain gaps should be published.
+- Optional: none.
+- Fallback: If the relevant simulation entrypoint, preset, logs, or run artifacts cannot be found, stop and report the missing evidence instead of inferring behavior from stale docs or memory.
+
+## Standards
+
+- Evidence: Base conclusions on the actual preset, runtime command, logs, SQLite event store, local stub responses, and the code paths that generated them.
+- Execution: Reproduce with the exact scenario first, separate product logic failures from simulation-toolchain failures, make the smallest realistic toolchain fix, and rerun the same bounded scenario to validate.
+- Quality: Prefer harness or stub fixes that improve realism over one-off scenario hacks, avoid duplicating existing workflow skills, and record reusable presets when a scenario becomes part of the regular test suite.
+- Output: Return the scenario contract, observed outcomes, root-cause chain, fixes applied, validation evidence, and any remaining realism gaps.
+
+## Goal
+
+Use this skill to debug simulation workflows where the repository exposes a production-like local run path, but the observed outcomes are distorted by presets, harness logic, local stubs, event persistence, or runtime scheduling constraints.
+
+## Workflow
+
+### 1) Lock the simulation contract before touching code
+
+- Identify the exact entrypoint, preset, duration, runtime mode, and rate-limit tier the user expects.
+- Read the preset or scenario definition from the repository before assuming what the test means.
+- Capture the intended success criteria explicitly, such as:
+  - successful liquidation count
+  - remediation count
+  - oracle-block registration
+  - profit ranking behavior
+  - quote budget behavior
+- If the scenario is ad hoc but likely to recur, prefer turning it into a named preset instead of leaving it as an undocumented shell invocation.
+
+### 2) Reproduce with the real bounded run path
+
+- Use the same production/local simulation script the repository already treats as canonical.
+- Prefer a bounded run window with a stable run name and output directory.
+- Save and inspect the exact artifacts produced by that run:
+  - main runtime log
+  - actor or stub logs
+  - generated env/config files
+  - SQLite or other persistence outputs
+  - scenario manifest or preset-resolved settings
+- Do not trust older run directories when the user asks about a new execution.
+
+### 3) Audit the artifact chain before diagnosing product logic
+
+- Confirm that you are reading the correct database and log files for the active run.
+- Verify that the event tables you expect are actually the ones written by the runtime.
+- Check whether missing results come from:
+  - no candidate selection
+  - no worker completion
+  - planner failure
+  - event persistence mismatch
+  - reading the wrong file
+- Treat this artifact audit as mandatory; repeated failures in the recent chats came from toolchain alignment errors before they came from liquidation logic.
+
+### 4) Separate product failures from toolchain realism failures
+
+- Classify each blocker into one of these buckets:
+  - preset design mismatch
+  - runtime scheduling or budget behavior
+  - stub or mock response unrealism
+  - local validator or cloned-state setup drift
+  - account ordering / remaining-account mismatch
+  - event-generation or persistence bug
+  - genuine product logic bug
+- If the symptom is caused by the local harness, fix the harness instead of masking it in runtime logic.
+- If a local stub inflates or distorts profitability, preserve the runtime behavior and calibrate the stub.
+- If a scenario intentionally stresses one dimension, make sure the harness is not accidentally stressing unrelated dimensions.
+
+### 5) Trace the full decision tree for missed liquidations or remediations
+
+- Follow the candidate from discovery through:
+  - local profitability estimate
+  - health precheck
+  - oracle-block classification
+  - remediation registration and rearm
+  - quote admission
+  - quote calibration
+  - pre-submit verification
+  - final execution or skip reason
+- When the runtime reports a generic or overloaded failure label, reopen the logs and derive a finer-grained breakdown before proposing fixes.
+- Distinguish fail-closed behavior from broken behavior; not all skipped liquidations are bugs.
+
+### 6) Fix the narrowest realistic cause
+
+- Prefer minimal fixes that improve realism or observability at the root cause:
+  - add preset support to shell tooling instead of hardcoding another branch
+  - make oracle-blocked paths avoid external quote I/O when a local estimate is sufficient
+  - make stubs preserve run-specific metadata instead of falling back to unrealistic defaults
+  - keep continuous oracle updates realistic without breaking the runtime's own core feeds
+- Add or update regression tests when the bug is in the harness, runtime decision tree, or event persistence path.
+- If the scenario becomes a durable benchmark, add or update the named preset and the developer docs in the same change.
+
+### 7) Re-run the same scenario and compare outcomes
+
+- After the fix, rerun the same scenario or the shortest bounded version that still exercises the bug.
+- Compare:
+  - event-table counts before and after
+  - dominant skip reasons before and after
+  - whether the runtime reaches the intended decision stage
+  - whether the harness still resembles the user’s requested market conditions
+- Do not claim success based only on unit tests when the original issue was a simulation-toolchain integration problem.
+
+## Common failure patterns
+
+- **Wrong artifact source**: the analyst inspects an older SQLite file or the wrong event database and concludes that runtime behavior is missing.
+- **Preset says one thing, harness does another**: scenario names sound right, but the actual matrix or oracle mode does not match the user’s intent.
+- **Stub realism drift**: local quote, swap, or oracle stubs distort pricing, accounts, or program IDs enough to create false failures or false profits.
+- **Overloaded “unknown” failures**: logs contain structured reasons, but the first-pass analysis never decomposes them.
+- **Continuous-mode self-sabotage**: a stress regime intended to stale pull oracles instead makes the runtime’s own primary feeds unusable.
+- **Quote budget starvation**: local filtering improves behavior but still lets low-value cross-mint candidates consume scarce quote capacity before higher-value paths can finish.
+
+## Output checklist
+
+- Name the exact scenario, preset, duration, and run directory.
+- State whether the root cause was product logic, toolchain realism, or both.
+- Cite the artifact types used: preset, logs, SQLite tables, and code paths.
+- Summarize the narrow fix and the regression test or rerun evidence.
+- If the final scenario should be reused, state where the preset or docs were added.
+
+## Example invocation
+
+`Use $production-sim-debug to run the repository's production local simulation for 5 minutes with the named preset, explain why liquidations did not land, and fix any local harness or runtime-alignment issues that make the simulation unrealistic.`

package/production-sim-debug/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "Production Sim Debug"
+  short_description: "診斷 production/local simulation 工具鏈與結果失真"
+  default_prompt: "Use $production-sim-debug to investigate a production/local simulation run, explain why outcomes diverged, and fix the harness or runtime alignment if needed."

package/read-github-issue/SKILL.md

@@ -0,0 +1,99 @@
+---
+name: read-github-issue
+description: Read and search remote GitHub issues via GitHub CLI (`gh`). Use when users ask to list issues, filter issue candidates, inspect a specific issue with comments, or gather issue context before planning follow-up work. Prefer the bundled scripts when they are present and working, but fall back to direct `gh issue list` / `gh issue view` commands when the scripts are missing or fail for repository-specific reasons.
+---
+
+# Read GitHub Issue
+
+## Dependencies
+
+- Required: none.
+- Conditional: none.
+- Optional: none.
+- Fallback: If the bundled scripts are missing or fail but `gh` is available, continue with raw `gh issue list` / `gh issue view`; only stop when `gh` itself is unavailable or unauthenticated.
+
+## Standards
+
+- Evidence: Verify repository context first, then read remote issue data directly from `gh issue list` / `gh issue view` instead of paraphrasing from memory.
+- Execution: Confirm the target repo, prefer the bundled scripts for deterministic output, then fall back to raw `gh` commands whenever the scripts are unavailable or broken in the target repository.
+- Quality: Keep the skill focused on issue discovery and retrieval only; do not embed any hardcoded fixing, branching, PR, or push workflow.
+- Output: Return candidate issues, selected issue details, comments summary, and any missing information needed before follow-up work.
+
+## Overview
+
+Use this skill to gather trustworthy GitHub issue context with `gh`: discover open or closed issues, narrow them with labels or search text, then inspect a chosen issue in detail before any separate planning or implementation workflow begins.
+
+## Prerequisites
+
+- `gh` is installed and authenticated (`gh auth status`).
+- The current directory is a git repository with the correct `origin`, or the user provides `--repo owner/name`.
+
+## Workflow
+
+### 1) Verify repository and remote context
+
+- Run `gh repo view --json nameWithOwner,isPrivate,defaultBranchRef` to confirm target repo.
+- If the user specifies another repository, always use `--repo <owner>/<repo>` in issue commands.
+
+### 2) Find candidate issues with the bundled script
+
+- Preferred command:
+
+```bash
+python3 scripts/find_issues.py --limit 50 --state open
+```
+
+- Optional filters:
+  - `--repo owner/name`
+  - `--label bug`
+  - `--search "panic in parser"`
+- Raw `gh` fallback when the script is missing or broken:
+
+```bash
+gh issue list --limit 50 --state open
+```
+
+- Add `--repo <owner>/<repo>`, `--label <label>`, or `--search "<text>"` as needed.
+- If the issue target is still unclear, present top candidates and ask which issue number or URL should be inspected next.
+
+### 3) Read a specific issue in detail
+
+- Preferred command:
+
+```bash
+python3 scripts/read_issue.py 123 --comments
+```
+
+- Optional flags:
+  - `--repo owner/name`
+  - `--json`
+  - `--comments`
+- Raw `gh` fallback when the script is missing or broken:
+
+```bash
+gh issue view 123 --comments
+```
+
+- Use `--repo <owner>/<repo>` when targeting a different repository.
+- Use the returned title, body, labels, assignees, state, timestamps, and comments to summarize the issue precisely.
+
+### 4) Summarize gaps before any follow-up action
+
+- Identify missing acceptance criteria, repro details, affected components, or environment context.
+- If issue text and comments are insufficient, state exactly what is missing instead of inventing a fix plan.
+
+## Included Script
+
+### `scripts/find_issues.py`
+
+- Purpose: consistent remote issue listing via `gh issue list`.
+- Outputs a readable table by default, or JSON with `--output json`.
+- Uses only GitHub CLI so it reflects remote GitHub state.
+- Treat it as a convenience wrapper, not a hard dependency.
+
+### `scripts/read_issue.py`
+
+- Purpose: deterministic issue detail retrieval via `gh issue view`.
+- Outputs either a human-readable summary or full JSON for downstream automation.
+- Can include issue comments so the agent can read the latest discussion before taking any other step.
+- Treat it as a convenience wrapper, not a hard dependency.

package/read-github-issue/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "Read GitHub Issue"
+  short_description: "Read and search remote GitHub issues"
+  default_prompt: "Use $read-github-issue to verify the target GitHub repository with gh, prefer the bundled issue scripts when they work, fall back to raw gh issue commands when they do not, inspect the selected issue with comments and structured fields, summarize the trustworthy issue context, and call out any missing details before any separate planning or implementation work."

package/{fix-github-issues/scripts/list_issues.py → read-github-issue/scripts/find_issues.py}

@@ -17,7 +17,7 @@ def positive_int(raw: str) -> int:
 
 def parse_args() -> argparse.Namespace:
     parser = argparse.ArgumentParser(
-        description="List remote GitHub issues with gh CLI and display table or JSON output."
+        description="Find remote GitHub issues with gh CLI and display table or JSON output."
     )
     parser.add_argument("--repo", help="Target repository in owner/name format.")
     parser.add_argument("--state", default="open", choices=["open", "closed", "all"])

package/read-github-issue/scripts/read_issue.py

@@ -0,0 +1,108 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import json
+import subprocess
+import sys
+
+
+ISSUE_FIELDS = "number,title,body,state,author,labels,assignees,comments,createdAt,updatedAt,closedAt,url"
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Read a remote GitHub issue with gh CLI and display summary or JSON output."
+    )
+    parser.add_argument("issue", help="Issue number or URL.")
+    parser.add_argument("--repo", help="Target repository in owner/name format.")
+    parser.add_argument(
+        "--comments",
+        action="store_true",
+        help="Keep issue comments in formatted output.",
+    )
+    parser.add_argument(
+        "--json",
+        action="store_true",
+        help="Print raw JSON output.",
+    )
+    return parser.parse_args()
+
+
+def build_command(args: argparse.Namespace) -> list[str]:
+    cmd = [
+        "gh",
+        "issue",
+        "view",
+        args.issue,
+        "--json",
+        ISSUE_FIELDS,
+    ]
+    if args.repo:
+        cmd.extend(["--repo", args.repo])
+    return cmd
+
+
+def join_names(items: list[dict], key: str) -> str:
+    values = [item.get(key, "") for item in items if item.get(key)]
+    return ", ".join(values) if values else "-"
+
+
+def print_summary(issue: dict, include_comments: bool) -> None:
+    print(f"Number: #{issue.get('number', '')}")
+    print(f"Title: {issue.get('title', '')}")
+    print(f"State: {issue.get('state', '')}")
+    print(f"URL: {issue.get('url', '')}")
+    print(f"Author: {(issue.get('author') or {}).get('login', '-')}")
+    print(f"Labels: {join_names(issue.get('labels', []), 'name')}")
+    print(f"Assignees: {join_names(issue.get('assignees', []), 'login')}")
+    print(f"Created: {issue.get('createdAt', '')}")
+    print(f"Updated: {issue.get('updatedAt', '')}")
+    print(f"Closed: {issue.get('closedAt', '') or '-'}")
+    print("")
+    print("Body:")
+    print(issue.get("body", "") or "-")
+
+    if include_comments:
+        comments = issue.get("comments", [])
+        print("")
+        print(f"Comments ({len(comments)}):")
+        if not comments:
+            print("-")
+            return
+        for comment in comments:
+            author = (comment.get("author") or {}).get("login", "-")
+            created = comment.get("createdAt", "")
+            body = comment.get("body", "") or "-"
+            print(f"- [{created}] {author}: {body}")
+
+
+def main() -> int:
+    args = parse_args()
+    cmd = build_command(args)
+
+    try:
+        result = subprocess.run(cmd, check=True, capture_output=True, text=True)
+    except FileNotFoundError:
+        print("Error: gh CLI is not installed or not in PATH.", file=sys.stderr)
+        return 1
+    except subprocess.CalledProcessError as exc:
+        print(exc.stderr.strip() or "gh issue view failed.", file=sys.stderr)
+        return exc.returncode
+
+    try:
+        issue = json.loads(result.stdout)
+    except json.JSONDecodeError:
+        print("Error: unable to parse gh output as JSON.", file=sys.stderr)
+        return 1
+
+    if args.json:
+        print(json.dumps(issue, indent=2))
+        return 0
+
+    print_summary(issue, include_comments=args.comments)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/{fix-github-issues/tests/test_list_issues.py → read-github-issue/tests/test_find_issues.py}

@@ -12,13 +12,13 @@ from pathlib import Path
 from unittest.mock import patch
 
 
-SCRIPT_PATH = Path(__file__).resolve().parents[1] / "scripts" / "list_issues.py"
-SPEC = importlib.util.spec_from_file_location("list_issues", SCRIPT_PATH)
+SCRIPT_PATH = Path(__file__).resolve().parents[1] / "scripts" / "find_issues.py"
+SPEC = importlib.util.spec_from_file_location("find_issues", SCRIPT_PATH)
 MODULE = importlib.util.module_from_spec(SPEC)
 SPEC.loader.exec_module(MODULE)
 
 
-class ListIssuesTests(unittest.TestCase):
+class FindIssuesTests(unittest.TestCase):
     def test_build_command_with_filters(self) -> None:
         args = Namespace(
             repo="owner/repo",