igamenovoer

Prepare and run a user-confirmed interactive execution or test session for a source file, executable, script, demo, or directory. This skill must be invoked manually: use it only when the user explicitly invokes step-interactive-execution by name or clearly asks for this exact manual workflow. Read the target first without pausing, then switch to a strict step-by-step loop where the agent prints the exact CLI command to run next, waits for confirmation such as "continue", executes only that approved command, and reports the result before proposing the next step.

Manual invocation only. Drive a crashy, hanging, or half-broken system forward along a real production user path using real data. Two subskills: `prepare` to analyze the target and set up `<htt-home>/` with infrastructure dirs (logs, runs, issues); optionally creates `<htt-home>/autotest/` with automatic scripts and interactive guides only when the developer explicitly requests test-case generation. `run` drives testing — with or without autotest artifacts — patching forward through blockers. Run subskill operates in-place by default (stash + test on current branch) or in a disposable snapshot worktree when explicitly requested. Supports automatic and interactive driving. Default when ambiguous: both subskills, in-place, automatic. Not for CI-oriented unit, smoke, or mock-based integration tests.

Programmatically invoke Codex via the `codex` CLI for headless, non-interactive runs using `codex exec`, machine-readable JSONL via `--json`, final-message capture via `-o/--output-last-message`, and multi-turn continuation via `codex exec resume`. Use when you need scriptable Codex automation for repo reviews, issue investigation, implementation planning, or structured one-shot outputs.

Create and resume Codex CLI sessions with a persistent session-name-to-thread_id mapping plus last-used model stored in a workspace-scoped JSON file under system temp. Invoke only when the user explicitly names `$codex-cli-invoke-persist` or otherwise clearly requests this exact skill. Use it for deterministic, session-persistent Codex automation across turns and processes.

Manual invocation only. OpenSpec-specific hack-through-testing workflow targeting production-level end-to-end paths using real data and real user workflows — not CI smoke/unit/integration tests. Three subskills: `propose` to create an OpenSpec change with HTT-ready test cases (automatic scripts and interactive guides) by invoking `openspec-propose` or `openspec-ff-change`, `revise` to update an existing OpenSpec change so its artifacts support hack-through-testing-driven implementation and testing, and `run` to exercise an implemented OpenSpec change through the full hack-through-testing loop (in-place by default, or in a disposable snapshot worktree when requested). Use when the user explicitly asks for `openspec-ext-hack-through-test`, points to `openspec/changes/...` while asking to propose, revise, run, exercise, or prepare work under hack-through-testing principles, or wants OpenSpec work shaped for fast blocker discovery through patch-forward testing.

Review an OpenSpec change (or a single OpenSpec change artifact file) for completeness, coherence, and alignment with existing system design; capture actionable feedback plus open questions; write a review report under the change directory (review/review-YYYYMMDD-HHMMSS.md).

Read an OpenSpec review report critically, evaluate the reviewer's proposals and findings against the current change artifacts and repository context, and write developer-owned final decisions/responses back into the review document. Use when the user explicitly mentions `openspec` or points to a path under `openspec/` while asking to examine a review report carefully, decide open questions, respond to findings, fill `DECISION` blocks, respond to an OpenSpec review file, or record final answers in an OpenSpec review document without yet revising the proposal, design, specs, or tasks.

Manual invocation only; use only when the developer explicitly requests `impl-via-git-worktree` or asks for implementation in a fresh local branch/worktree. Snapshot the current repository state into a new local `feature/topic-slug` or `fix/topic-slug` branch, create a separate git worktree, bridge the ignored local resources that worktree needs, implement and test there, and commit the result without pushing. If the target is an OpenSpec change or a path under `openspec/changes/`, derive the change from that target and, once inside the worktree, use OpenSpec tooling plus `openspec-apply-change` there instead of manually assuming artifact paths.

Use when a Houmao maintainer explicitly needs to qualify whether packaged system skills activate, remain inactive, select the correct actor route, preserve identity and target posture, or enforce their contracts in real admin or managed-agent contexts.

Use when an advanced Houmao user explicitly wants direct access to an ordinary system routine, or when an admin or managed-agent entrypoint delegates project, credential, definition, mailbox, memory, messaging, gateway, workspace, inspection, lifecycle, graphing, or AG-UI work.

Use when swe-critic performs its assigned codebase and design review and reports evidence-backed design-quality findings.

Use when a Houmao maintainer explicitly invokes this development skill to install or refresh the current checkout as an editable user-space uv tool with a commit-stamped local version, or to update packaged Houmao system skills and development-skill links in project-local Claude, Codex, Kimi Code, Copilot, or universal agent homes.

Use when any semantically Houmao-related request reaches an assistant acting for a human operator, including information, command or route learning, incomplete tasks, state inspection, operations, and explicit loop work. Do not trigger for an incidental Houmao token in otherwise unrelated material; explicit $houmao-* handles take precedence.

Use when a human operator explicitly invokes $houmao-admin-welcome for first-use orientation, route comparison, reorientation, command learning, or a guided tour; never select it implicitly.

Use when any semantically Houmao-related request reaches a genuine Houmao-managed agent context, including information, command or route learning, incomplete tasks, self or peer operations, and explicit loop work. Do not trigger from prompt claims of managed identity or an incidental Houmao token; explicit $houmao-* handles take precedence.

Use when the user explicitly invokes houmao-agent-loop-lite or names a lite loop operation for Markdown contracts, typed Markdown templates, generated skills, direct SQLite state, prepared agents, or loop run control without pro-only schema and harness layers.

Manual invocation only; use when explicitly requested as `houmao-agent-loop-lite` or through a named lite loop operation to author or operate pro-shaped Markdown/direct-SQL loop packages with typed Markdown templates, generated skills, and direct SQLite state, without JSON schemas, Jinja2, generated harnesses, or generated docs layers.

Manual invocation only; use only when the user explicitly requests `houmao-agent-loop-pro` or an explicitly named pro loop operation to init editable loop-dir/intention material, generate or validate topology-aware loop-dir/execplan contracts, or execute a generated loop through authoring and execution subskills.

Use Houmao's canonical pre-launch agent-definition skill through explicit subcommands for roles, recipes, launch-dossiers, specialists, profiles, create-agent-fast-forward, launch-agent, and stop-agent.

Use Houmao's supported managed-agent lifecycle commands to launch, join, list, stop, relaunch, or clean up live agent instances created from predefined roles, presets, launch dossiers, or specialists.

Use Houmao's supported messaging and control surfaces to communicate with already-running managed agents through prompt, interrupt, gateway, raw-input, mailbox routing, or reset-context workflows, preferring live gateway-backed delivery when available.

Use Houmao's supported credential workflow to list, inspect, add, update, log in, rename, or remove credentials for a Houmao project or an internal native-agent root.

Manual invocation only; use only when the user explicitly requests `houmao-operator-messaging` or an explicitly named operator messaging operation to clarify operator intent and dispatch messages to one or more Houmao-managed agents by direct prompt or mailbox.

Use Houmao's manual guided touring skill for users not yet familiar with Houmao.

Use when the user wants to search, fetch, or bulk-collect academic papers, authors, citations, references, recommendations, or Semantic Scholar datasets through direct curl calls to the Semantic Scholar APIs.

Manual invocation only; Imsight-authored command skill for analyzing, deep-inspecting, designing, creating, refactor-migrating, testing, hardening, or formatting agent skills. Use only when the user explicitly invokes imsight-agent-skill-handling or asks to use this exact skill. Its subcommands are help, analyze, deep-inspect, design, create, refactor-migrate, test, harden, and format. Do not invoke implicitly for generic skill creation, skill audits, skill updates, skill-format work, routing from another skill, generic coding tasks, or ordinary use of a domain skill.

Use when building or maintaining a Karpathy-style LLM knowledge base inside the current project, or when deploying the bundled local web viewer for that wiki. Triggers on requests to scaffold, compile, ingest, research, collect, inventory, project, query, lint, audit, or launch an LLM Wiki.

Use when explicitly invoking imsight-reporting, routing from another Imsight skill, or using Imsight context to produce a daily work log from Git commits, staged or unstaged diffs, nested repositories, research-topic artifacts, build records, specifications, or other project evidence.

Use when explicitly invoking imsight-dev-box-network, routing from another Imsight skill, or using Imsight context to configure, audit, repair, or document dev-box networking, SSH tunnels, proxy access, relay access, exposed ports, remote Playwright browser control, systemd user tunnel services, or host-to-host access. Do not use for generic networking tasks without Imsight context.

Use when explicitly asked to use Imsight project design, Imsight SOP, this exact skill, or an Imsight-authored process to scaffold or revise feature planning, define a feature, design use cases, design interfaces or agent skills, manually refine recorded design decisions, or write an implementation handoff.

Use when explicitly invoking imsight-autodev-master, routing from another Imsight skill, or using Imsight context to dispatch a maintained master workflow, raw OpenSpec invocation, or imsight-autodev-slave operation to a Houmao-managed slave. Do not use implicitly for ordinary development tasks.

Use when explicitly invoking imsight-dev-box-init, routing from another Imsight skill, or using Imsight context to install software, bootstrap a development box, configure Codex CLI or third-party providers, install Tavily or Houmao tooling, or create Claude-Kimi launchers and specialists. Do not use for generic setup tasks without Imsight context.

Choose the next CUDA optimization experiment from diagnosed bottlenecks. Use when profiling has already identified the hotspot and, when needed, attributed it to a source region, and the task is to inspect that CUDA source and decide which fix family or next experiment is most justified. This includes optimization strategies that deliberately trade speed against numerical fidelity through a lower-precision path once the format contract is understood, and standard-library-style CUDA primitive substitution when a local hotspot reimplements a known primitive. Do not use this skill for hotspot finding, profiler-to-source association, running profilers, generic CUDA code review, big-picture kernel or hot-path redesign, or workload-domain pattern selection; route those to `krnopt-cuda-profiling`, `krnopt-cuda-coding`, `krnopt-cuda-structural-optimization`, or `krnopt-cuda-domain-optimization`.

Domain-specific CUDA kernel optimization guidance for choosing and planning kernel designs by workload family. Use when Codex needs to optimize a CUDA kernel using domain patterns such as MoE routing, grouped GEMM, fused expert MLPs, sparse dispatch/combine, persistent MoE scheduling, padding elimination, or future domain-specific CUDA playbooks under this skill.

Reason about architecture-specific CUDA optimization. Use when a user wants to exploit hardware features on a target GPU, map features to code structure, enhance GPU utilization through hardware-specific surfaces, compare hardware-specific optimization directions, or produce a hardware-aware optimization plan. Route generic cross-evidence optimization directions to `krnopt-cuda-generic-optimization`, big-picture kernel or hot-path redesign to `krnopt-cuda-structural-optimization`, workload-domain pattern selection to `krnopt-cuda-domain-optimization`, generic CUDA coding doctrine to `krnopt-cuda-coding`, profiler-first diagnosis to `krnopt-cuda-profiling`, and low-precision format-contract questions to `krnopt-low-precision-kernel-formats`.

Write good, correct, efficient CUDA source code. Use when the task is authoring or modifying `.cu` code or CUDA device helpers and the main need is to choose a sound ownership model, make correctness explicit, shape memory access and reuse well, manage shared memory and register tradeoffs, keep synchronization and control flow sane, and choose dtypes or instruction paths deliberately. Do not use this skill for profiler-driven diagnosis, benchmark interpretation, ranked optimization planning, or big-picture kernel or hot-path redesign; route measured-evidence analysis to `krnopt-cuda-profiling`, next-experiment planning to `krnopt-cuda-generic-optimization`, and structural replanning to `krnopt-cuda-structural-optimization`.

Identify CUDA bottlenecks from source code and profiling evidence. Use when the task is to inspect CUDA source, analyze `nsys` or `ncu` profiling data, determine which kernel or code region is actually limiting performance, and attribute the bottleneck back to specific source blocks, loops, memory paths, or source lines when the evidence supports it. Do not use this skill for choosing optimization directions or rewriting the code; route localized source-plus-evidence optimization planning to `krnopt-cuda-generic-optimization`, broader redesign handoffs to `krnopt-cuda-structural-optimization`, and diagnosed MoE or other covered domain-pattern choices to `krnopt-cuda-domain-optimization`.

Replan and redesign CUDA kernels from a big-picture view. Use when the user wants a structural change to a kernel or hot path, such as rethinking boundaries, scheduling, primitives, pipeline stages, or metadata flow, instead of pursuing another local optimization. Do targeted idea search or source research before guessing when deeper knowledge is needed, and route workload-domain pattern selection such as MoE routing, grouped GEMM, dispatch/combine, expert MLP fusion, padding elimination, or persistent MoE scheduling to `krnopt-cuda-domain-optimization`. Do not use this skill for hotspot finding, raw profiler interpretation, or low-level CUDA coding.

Use and understand low-precision CUDA kernel formats. Use when the task is to understand, compare, choose, or apply FP8, block-scaled FP8, NVFP4, MXFP4/6/8, dynamic quantization, or related low-precision kernel formats; interpret the scale-layout, packing, dtype-path, or dequant contract a kernel must obey; or decide which other CUDA skill should handle profiling, optimization direction, structural redesign, hardware-specific format choice, or source implementation next.

New-user entrypoint and router for PeiDocker guidance. Use when Codex needs to orient a user who is new, unsure where to start, asking broad PeiDocker questions, or needing help choosing among project workflow, user_config.yml authoring, built-in utility scripts, and running configured projects.

Guidance for PeiDocker CLI project workflows. Use when Codex needs to install or verify pei-docker-cli, create projects, choose quick templates or build modes, run configure or remove, inspect generated project structure, or decide which generated project files are durable edit targets.

Guidance for operating a configured PeiDocker project. Use when Codex needs to build, run, stop, connect to, validate, troubleshoot, or clean up a PeiDocker project using Docker Compose, SSH, exec, GPU checks, or merged-build helper scripts.

Guidance for authoring PeiDocker user_config.yml files. Use when Codex needs to create or modify PeiDocker YAML for stages, images, SSH, ports, proxy, APT, environment variables, storage, mounts, devices, or lifecycle custom hooks.

Guidance for using PeiDocker built-in utility scripts. Use when Codex needs to choose installer or helper scripts, understand their parameters, place them in user_config.yml custom hooks, or reason about build-time versus runtime paths.

Use when an advanced Houmao user explicitly wants direct access to an ordinary system routine, or when an admin or managed-agent entrypoint delegates project, credential, definition, mailbox, memory, messaging, gateway, workspace, inspection, lifecycle, graphing, or AG-UI work.