cluxion-agentplugin-supercoder 0.2.14__tar.gz → 0.2.15__tar.gz

cluxion_agentplugin_supercoder-0.2.15/.grok-briefs/ci-hermes-probe-skip.md

@@ -0,0 +1,36 @@
+# Task: doctor hermes-dependent critical probes must SKIP when hermes absent + env-independent test (CI fix #2)
+
+## Context
+CI (no `hermes` binary on PATH) STILL fails: `tests/test_doctor.py` test
+`test_critical_skip_marks_degraded_summary` expects summary=="degraded" but gets "fail".
+Root cause: critical probes `hermes_on_path` (probes.py:27) and `hermes_oneshot_flag` (probes.py:46)
+FAIL when hermes isn't on PATH (the CI build runner has no hermes). That makes summary "fail" instead
+of "degraded". The sibling ultracode plugin already fixed this by skipping hermes probes when hermes
+is absent — MIRROR that approach here.
+
+## Fix
+1. `doctor/probes.py`: `hermes_on_path` and `hermes_oneshot_flag` (and any probe needing the hermes
+   binary): when `shutil.which(ctx.hermes_bin)` is None, return `("skip", "hermes binary not on PATH
+   — cannot verify")` instead of fail. FAIL only when hermes IS present but the contract is violated.
+2. Make `tests/test_doctor.py`'s honest-summary test ENVIRONMENT-INDEPENDENT — it must pass whether or
+   not hermes/native exist on the machine. Best: unit-test the summary computation directly (feed a
+   controlled statuses dict — one critical "skip" + rest "pass" → assert "degraded"; one critical
+   "fail" → assert "fail"). If it runs the real doctor, monkeypatch `shutil.which` so hermes appears
+   absent and assert degraded (not fail).
+
+## Invariants (MUST hold)
+- hermes absent → hermes probes SKIP → summary "degraded". hermes present + valid → PASS.
+- Critical SKIP → "degraded"; critical FAIL → "fail" (unchanged). Security/cursor probes UNCHANGED.
+
+## Tests (CRITICAL — CI is a NO-hermes, NO-native environment)
+- `uv run pytest` must be green REGARDLESS of whether hermes/native are installed. The honest-summary
+  test must NOT depend on the machine having hermes. (If unsure, make it a pure unit test of the
+  summary function.)
+- `uv run ruff check .` clean.
+
+## Out of scope
+- No version bump. No change to the P0 security fix or DB/other probes beyond skip-on-absence.
+
+## Done
+hermes-dependent probes skip when hermes absent; honest-summary test is environment-independent;
+pytest green with no hermes/native. Concise diff.

cluxion_agentplugin_supercoder-0.2.15/.grok-briefs/fix-empty-oldtext-infinite-loop.md

@@ -0,0 +1,28 @@
+# Task: supercoder hash_patch — fix infinite loop / OOM on empty old_text (_exact_spans empty-needle)
+
+## Context (LIVE-VERIFIED crash — user-facing)
+0.2.12 installed. `apply_patch(path, old_text="", new_text=...)` HANGS in an infinite loop and OOMs (process killed, exit 124 on timeout / 137 on OOM). Root cause in `core/hash_patch.py::_exact_spans`:
+```python
+while True:
+    start = text.find(needle, offset)
+    if start < 0:
+        return spans
+    spans.append((start, start + len(needle)))
+    offset = start + len(needle)
+```
+With `needle == ""`, `text.find("", offset)` ALWAYS returns `offset` (never -1) and `offset += len("") == 0`, so `offset` never advances → infinite `spans.append` → unbounded memory → OOM. Reproduced live: `_exact_spans('hello', '')` times out (exit 124); `apply_patch(x, old_text='', new_text='INSERT')` times out. Any caller passing an empty `old_text` hangs the whole process. Do NOT bump the version. Do NOT touch `.grok-briefs/`.
+
+## Fix
+1. In `_exact_spans`: guard the empty needle at the top — `if not needle: return []` (an empty search string has no meaningful patch target).
+2. In `apply_patch`: reject empty `old_text` early, BEFORE acquiring the lock / scanning, with a clear failure:
+   `if not old_text: return _failed(str(path), "empty_old_text", expected_file_hash, "old_text must be non-empty")`.
+3. Audit `_candidate_spans` / `_best_fuzzy_span` for the same empty-`reference` hazard: if `reference == ""` produces a degenerate or huge candidate set (or a misleading match), guard it too (e.g. early no_match / `if not reference: return []`). Verify with a timeout test that empty reference does not hang.
+
+## Invariant + tests (MANDATORY)
+- `apply_patch(..., old_text='')` returns a FAST failure (`success=False`, strategy/message indicating empty old_text), with NO hang — add a test asserting it returns in well under a second (e.g. wrap with a thread + timeout, or just assert it returns and check the strategy).
+- `_exact_spans(text, '')` returns `[]` immediately.
+- Non-empty old_text behavior is UNCHANGED (existing exact / fuzzy / ambiguity / concurrency tests stay green).
+- `uv run pytest` GREEN; `uv run ruff check .` pass.
+
+## Done
+- Empty old_text no longer hangs/OOMs; it returns a fast, clear failure. Tests added proving no-hang. No version bump. No `.grok-briefs/` edits. Concise diff.

cluxion_agentplugin_supercoder-0.2.15/.grok-briefs/fix-hash-patch-race-0619.md

@@ -0,0 +1,30 @@
+# Task: supercoder hash_patch — fix concurrent lost-update race (flock on a replaced inode)
+
+## Context
+A live stress run found `tests/test_hash_patch.py::test_concurrent_patches_no_lost_update` is FLAKY (~1 in 12-15 runs): 8 concurrent ThreadPoolExecutor workers each apply a distinct, non-overlapping patch to the same file. Occasionally one marker stays `# UNIQUE_PATCH_i_START` (a lost update) even though every worker returns `success=True`. This is a real concurrency bug: two agents/threads patching the same file can silently lose one patch (user-facing code loss). Do NOT bump the version (deploy handled separately). Do NOT touch `.grok-briefs/`.
+
+## Root cause (verified by reading `core/hash_patch.py`)
+`_exclusive_lock(path)` does `os.open(path)` then `fcntl.flock(fd, LOCK_EX)`. But `_commit` → `_atomic_write` finalizes via `os.replace(tmp, path)`, which swaps `path` to a NEW inode. The flock is held on the OLD inode, so the lock does not actually serialize writers across the replace. Sequence that loses a patch:
+1. Thread A: `os.open(path)` → inode1; acquires flock(inode1).
+2. Thread B: `os.open(path)` → inode1 (before A's replace); blocks on flock(inode1).
+3. A: reads inode1, patches its marker, `_atomic_write` → `os.replace` → `path` now = inode2; A releases flock(inode1).
+4. B: acquires flock(inode1), but reads **inode1** (STALE — A's change is in inode2, not inode1), patches only its own marker, `os.replace` → `path` = inode3. **A's patch is lost.**
+Because the lock lives on a file that is replaced out from under it, two writers can serialize on DIFFERENT inodes and lose updates. Additional window: when `path` does not exist, `_exclusive_lock` yields WITHOUT any lock (`if fcntl is None or not path.exists(): yield; return`), so concurrent creation is unserialized too.
+
+## Fix
+Lock on a STABLE sidecar lock file whose inode never changes, instead of on the target file that gets replaced:
+- Choose a fixed lock path next to the target, e.g. `lock_path = path.parent / f".{path.name}.cluxion-lock"`.
+- `_exclusive_lock` opens the lock file with `os.open(lock_path, os.O_CREAT | os.O_RDWR, 0o600)`, `fcntl.flock(fd, fcntl.LOCK_EX)`, yields, then `fcntl.flock(fd, fcntl.LOCK_UN)` and `os.close(fd)` in `finally`.
+- Do NOT delete the lock file (deleting it reintroduces an inode/unlink race); leaving an empty `.cluxion-lock` is harmless and gets reused.
+- The lock file inode is never `os.replace`d, so all threads AND processes serialize correctly regardless of the target's atomic replace.
+- Acquire the lock even when `path` does not yet exist (the lock file is always creatable), so creation is serialized too. Keep the actual "file not found" handling in `apply_patch` as-is (it returns missing_file), but acquire/serialize first if you choose to create files later — at minimum, the existing-file patch path must serialize.
+- Graceful degrade when `fcntl is None` (non-POSIX, e.g. Windows): fall back to a module-level `threading.Lock()` so at least same-process thread safety holds (the test is single-process multithread, so this fallback alone fixes the test on platforms without fcntl).
+- Read-modify-write (`path.read_text` → match → `_atomic_write`) must stay entirely INSIDE the lock (it already is — keep it).
+
+## Invariant + tests
+- Make `test_concurrent_patches_no_lost_update` pass DETERMINISTICALLY. Add a stress test that runs the 8-worker scenario in a loop (e.g. 50 iterations) and asserts ZERO lost updates across all iterations (all 8 markers end `_DONE`, none `_START`, every worker success).
+- No regression: existing exact / fuzzy / stale-hash / `test_atomic_write_interruption_leaves_original_intact` tests still pass.
+- `uv run pytest` GREEN, `uv run ruff check .` pass.
+
+## Done criteria
+- Race fixed at the lock layer (sidecar lock file + threading.Lock fallback). Deterministic stress test added. No version bump. No `.grok-briefs/` edits. Concise diff summary.

cluxion_agentplugin_supercoder-0.2.15/.grok-briefs/fix-live-audit-0619.md

@@ -0,0 +1,27 @@
+# Task: supercoder — fix 3 live-audit defects (1 P2 false-degraded doctor + 2 P3)
+
+## Context
+Installed build is 0.2.9. A live adversarial audit (running the installed site-packages build) confirmed 3 REAL defects. Fix all in repo `src/`. Do NOT regress the 15 live-verified working functions. Do NOT bump the version in pyproject (deploy handled separately). Do NOT touch `.grok-briefs/`.
+
+## Defect 1 (P2 — FALSE HEALTH ALARM): `cluxion-supercoder doctor` reports 'degraded' / exit 1 on a fully-healthy install
+Running the plugin's own self-doctor on a correct install yields a red 'degraded' verdict and a non-zero exit status even though every real probe passes and the plugin is fully functional. Cause: a catalog check (`hermes_contract_tool_registration`) is marked 'critical' but has NO registered probe, so it is skipped, and a critical-skip is treated as failure → 'degraded'. This directly contradicts the user's standing requirement that the built-in doctor be a trustworthy self-monitor (a false-negative health report wastes turns and erodes trust).
+Fix (pick the correct one):
+  - PREFERRED: register a real probe for `hermes_contract_tool_registration` — it IS verifiable in-process (the `register()` wiring is already exercised by the `handler_exception_coverage` probe), so the probe can confirm the contract tools are registered and return pass; OR
+  - If it genuinely cannot be probed in this environment, treat a critical check that is SKIPPED (not failed) as NOT degrading overall health — i.e. overall status is 'degraded' only on a real FAIL, while an unprobeable critical is reported as 'skip' and overall stays ok. 
+Apply the same principle consistently: a skip is not a fail.
+Invariant + test: on a healthy install, `cluxion-supercoder doctor` → overall ok=True, exit 0; a genuine failure still → degraded/exit 1. Add an environment-independent test (monkeypatch) mirroring the pattern already used elsewhere.
+
+## Defect 2 (P3 — HONESTY): repo_map silently drops files beyond max_files cap
+REPO_MAP_SCHEMA / docstring promises "files beyond the character budget are counted in files_omitted, never silently dropped." But when `scan_repo` hits the `max_files` cap, the extra files are dropped with `files_omitted=0` and `truncated=false`, so the host model receives a PARTIAL orientation map believing it is COMPLETE.
+Fix: surface the file-count cap. When `scan_repo` hits `max_files`, either expose `files_scanned` vs a separate `files_capped` count, or set `truncated=True` and/or add the capped remainder to `files_omitted`, so the model knows the map is incomplete. Keep the existing character-budget omission accounting intact.
+Invariant + test: a repo with more files than `max_files` → result has `truncated=True` or `files_omitted>0` reflecting the capped files (never `omitted=0`+`truncated=false` while files were actually dropped).
+
+## Defect 3 (P3): is_coding_task naive substring match → false positives
+`is_coding_task` uses raw substring matching, so non-coding prompts are misrouted into the coding queue: 'latest' matches 'test', 'prefix' matches 'fix', etc. Bias is fail-toward-coding so output isn't wrong, but it wastes a repo scan and emits a misleading 'coding task' classification + repo_map for clearly non-coding prompts.
+Fix: use word-boundary matching (regex `\b<kw>\b` or tokenize-and-compare) instead of raw substring, so 'latest' does not match 'test' and 'prefix' does not match 'fix'. Keep the genuine-non-coding bypass branch.
+Invariant + test: 'what is the latest news' → NOT classified coding; 'fix the bug in main.py' → classified coding. Add tests for the false-positive words ('latest', 'prefix', 'contest') and true positives ('fix', 'test', 'refactor', 'debug').
+
+## Done criteria
+- `uv run pytest` GREEN. `uv run ruff check .` pass.
+- New tests for Defect 1 (healthy → ok/exit0, env-independent), Defect 2 (capped files surfaced), Defect 3 (word-boundary classification).
+- No version bump in pyproject. No edits under `.grok-briefs/`. Provide a concise per-defect diff summary.

cluxion_agentplugin_supercoder-0.2.15/.grok-briefs/p0-read-path-security.md

@@ -0,0 +1,51 @@
+# Task: Fix 2 P0 security holes in supercoder's read path (live-verified)
+
+## Context (both confirmed by live execution)
+1. **Secret-file read leak** — `read_window_tool` (src/cluxion_agentplugin_supercoder/runner.py:73-92)
+   and `cursor.read_window` (src/cluxion_agentplugin_supercoder/core/cursor.py:30-35) BYPASS the
+   security gate. `patch_tool` calls `pre_tool_gate` (runner.py:98) and refuses secret files, but the
+   read path never does. Live: `read_window_tool({'cwd':'/tmp','path':'.env'})` returned ok=True and
+   leaked `AWS_SECRET=...`; also leaks `credentials`, `sub/.env`. `supercoder_read_window` is a
+   REGISTERED host tool (plugin.py:25-31), so any agent can exfiltrate `.env`/`id_rsa`/`credentials`/
+   secrets. `tests/test_safety.py::test_secret_paths_blocked` proves the intent for the patch path.
+
+2. **Workspace sibling-directory escape** — `cursor.read_window` (core/cursor.py:33) uses
+   `str(path).startswith(str(root.resolve()))`. This is string-prefix, not containment. Live:
+   `read_window(Path('/tmp/work'), '../work2/secret.py')` leaked because `/tmp/work2` string-prefixes
+   `/tmp/work`. Plain `../` is caught, but a sibling dir sharing the name prefix escapes.
+   `safety._path_gate` (safety.py:~54) already does this correctly with `is_relative_to`, and
+   `tests/test_safety.py::test_sibling_directory_prefix_is_not_containment` regression-guards the
+   patch path.
+
+## Fix (mirror the patch path's existing, correct gate — do NOT invent a new policy)
+1. Route BOTH `cursor.read_window` and `read_window_tool` through the SAME secret-blocking +
+   containment gate the patch path uses (`pre_tool_gate` / `_path_gate` / `_SECRET_PARTS` in
+   safety.py and runner.py:98). Reading `.env`/`credentials`/`secrets`/`id_rsa` (the same
+   `_SECRET_PARTS` set patch uses) must return `ok=False` with the SAME message/shape as
+   `patch_tool` ("secret file access blocked").
+2. core/cursor.py:33 — replace the `startswith` prefix check with
+   `if not path.is_relative_to(root.resolve()): <reject>`. This closes BOTH plain `../` traversal
+   and the sibling-prefix escape.
+3. Legitimate in-workspace, non-secret reads MUST keep working unchanged (same return shape).
+
+## Reference
+- `safety.py`: `_path_gate` (~line 54, uses `is_relative_to`), `pre_tool_gate`, `_SECRET_PARTS`.
+- `runner.py:98`: `patch_tool` calls `pre_tool_gate` — mirror exactly for the read path.
+
+## Tests (MUST pass; add the missing coverage — tests/test_cursor.py currently has ZERO escape/secret tests)
+- read_window / read_window_tool on `.env` and `credentials` → blocked (ok=False, secret message).
+- read_window with a sibling-prefix escape (`/tmp/work` + `../work2/x`) → blocked.
+- read_window with plain `../../etc/passwd` → blocked.
+- read_window on a normal in-workspace file → STILL returns content (ok=True).
+- All existing `tests/test_safety.py` and other tests stay green. `uv run pytest` green.
+
+## Out of scope (DO NOT)
+- No version bump, build, wheel, pip install, or publish.
+- No change to patch-path semantics (already correct) or to the native backend.
+- Optional ONLY if zero-risk: doctor probe `_json_result`→`_wrap` misname (probes.py:111,114). The
+  two security fixes are the priority — never let probe cleanup endanger them.
+
+## Done
+read_window (both entry points) is gated identically to patch (secret-block + is_relative_to
+containment); new tests prove both P0s are closed and normal reads still work; all tests green.
+Report a concise diff summary and confirm the live exploits no longer reproduce.

cluxion_agentplugin_supercoder-0.2.15/.grok-briefs/p2-doctor-security-probes.md

@@ -0,0 +1,40 @@
+# Task: Complete supercoder doctor coverage — register the missing critical security probes
+
+## Context
+The doctor catalog declares 31 checks but probes.py registers only 12. The probes that would
+catch security holes are UNREGISTERED and silently skip — which is exactly how the two P0
+read-path holes (now FIXED: read_window secret leak + sibling-dir escape) reached a shipped
+build. Make doctor actually verify them so a regression can never silently ship again.
+
+## Implement (in doctor/probes.py — follow the EXISTING probe registration pattern)
+Register these catalog checks as real probes (the catalog's `detection_method` describes each test):
+1. `path_security_secrets_blocked` (critical) — assert BOTH `read_window_tool` AND `patch_tool` on a
+   `.env` (and another secret name like `credentials`) return ok=False with the secret-blocked
+   message. This is the regression guard for P0-1.
+2. `hermes_context_workspace_root` (critical) — assert `read_window` on `../../../etc/passwd` AND on
+   a sibling-prefix escape (workspace `/work` + path `../work2/x`) are blocked. Regression guard for
+   P0-2. (Both fixes already live in core/cursor.py + runner.py via pre_tool_gate + is_relative_to.)
+3. `patch_cursor_validity`, `stale_cursor_protection_enforced` (critical) — implement per their
+   catalog detection_method if feasible standalone. If a probe genuinely cannot run standalone,
+   make the doctor SUMMARY downgrade to "degraded" whenever a CRITICAL catalog check is unregistered
+   — never report green while a critical check silently skips.
+4. Fix `handler_exception_coverage` (probes.py:111,114): it imports a nonexistent `_json_result`;
+   the real symbol is `_wrap` (plugin.py:117). Point the probe at `_wrap` (wrap a raising callback,
+   assert it degrades to error-JSON), or delete the dead probe.
+
+## Invariants (MUST hold)
+- Probes are READ-ONLY and use temp dirs; never mutate the real workspace or touch real secrets.
+- Existing passing checks stay green; NO behavior change to runtime tools or the read-path fix.
+
+## Tests (must pass; prove the probes have teeth)
+- `uv run pytest` green. The new security probes PASS now (P0s fixed).
+- Add a focused test proving each security probe DETECTS an ungated read (e.g. monkeypatch the gate
+  to a no-op and assert the probe reports fail) — so the probe can't silently pass when broken.
+
+## Out of scope
+- No version bump / build / publish. No change to the read-path security fix (already correct).
+
+## Done
+doctor registers + passes path_security_secrets_blocked and hermes_context_workspace_root (with
+teeth-proving tests), handler_exception_coverage points at _wrap, summary never reports green while
+a critical check silently skips, all tests green. Concise diff summary.

cluxion_agentplugin_supercoder-0.2.15/.grok-briefs/perf-0619.md

@@ -0,0 +1,14 @@
+# Task: supercoder perf — _best_fuzzy_span quick_ratio pruning (59ms/call on large files, byte-identical)
+
+## Context
+0.2.11 installed. Direct profiling found `_best_fuzzy_span` is a REAL hot-path: fuzzy `apply_patch` on a 500-line file measured 59.3ms/call. The fuzzy path runs whenever exact match fails (common in code editing). Do NOT bump the version. Do NOT touch `.grok-briefs/`.
+
+## Optimization (LOW risk, MUST be byte-identical)
+File: `src/cluxion_agentplugin_supercoder/core/hash_patch.py` `_best_fuzzy_span` (152) + `_candidate_spans` (132).
+Current: for EVERY candidate span (all start_line × width-in-[target ± MAX_LINE_DRIFT] combinations) it computes `SequenceMatcher(None, block, reference, autojunk=False).ratio()` — O(spans × n²). On a 500-line file ≈ 59ms.
+Fix: use `SequenceMatcher`'s cheap UPPER-BOUND pruning. Construct ONE `sm = SequenceMatcher(autojunk=False)` and `sm.set_seq2(reference)` once (reference is fixed across candidates — this also avoids re-building the b2j index every candidate, a win by itself). Then per block: `sm.set_seq1(block)`, check the cheap upper bounds `sm.real_quick_ratio()` then `sm.quick_ratio()` (both are guaranteed `>= ratio()`), and only call the full `sm.ratio()` when the upper bound could still matter — i.e. when `quick_ratio >= best_score - AMBIGUITY_MARGIN` (use the existing ambiguity margin, 0.015) AND `>= 0` relative to whatever the code needs. Because `quick_ratio() >= ratio()`, any candidate whose `quick_ratio < best_score - margin` can NEITHER become the new best NOR fall within the ambiguity band, so skipping its `ratio()` is EXACTLY equivalent.
+CRITICAL — byte-identical result REQUIRED: the returned `(start, end, block, score, ambiguous)` MUST be identical to the current implementation for ALL inputs. The `ambiguous` flag logic (score within 0.015 of best, non-overlapping windows, `>= DEFAULT_FUZZY_THRESHOLD`) must evaluate to the same value. Be CONSERVATIVE: only prune a candidate's `ratio()` when its `quick_ratio` is strictly below the margin that could affect best OR ambiguity. When in doubt, compute `ratio()` (correctness over speed). Keep the iteration order identical so ties break the same way.
+Invariant: `_best_fuzzy_span` returns IDENTICAL output vs current for all inputs. Add a test comparing OLD vs NEW (keep a copy of the old function) across: exact-best-in-middle, two near-ties triggering `ambiguous=True`, a clear single best, and no-match (None). Assert identical `(start,end,score,ambiguous)`. Bench the large-file speedup.
+
+## Done
+- quick_ratio/real_quick_ratio pruning + set_seq2-once, IDENTICAL result, large-file fuzzy much faster. `uv run pytest` GREEN (esp. existing fuzzy + ambiguity + concurrency tests), `uv run ruff check .` pass. No version bump. No `.grok-briefs/` edits. Concise diff.

{cluxion_agentplugin_supercoder-0.2.14 → cluxion_agentplugin_supercoder-0.2.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cluxion-agentplugin-supercoder
-Version: 0.2.14
+Version: 0.2.15
 Summary: Universal agent coding harness plugin: cursor logic, safe patch, line budget, Rust index, test gates.
 Project-URL: Homepage, https://github.com/cluxion/cluxion-Agentplugin-supercoder
 Project-URL: Repository, https://github.com/cluxion/cluxion-Agentplugin-supercoder
@@ -73,6 +73,20 @@ cluxion-supercoder doctor --json   # 구조화 출력
 
 Hermes 안에서는 `supercoder_doctor` 도구로도 노출됩니다.
 
+## Hermes 슬래시 커맨드 (0.2.15+)
+
+```
+/supercoder fix failing auth tests and run gates
+/supercoder-doctor
+```
+
+| 슬래시 | 용도 |
+|---|---|
+| `/supercoder <task>` | 슈퍼코더 코딩 모드 — plan + repo map을 에이전트에 전달 |
+| `/supercoder-doctor` | doctor (CLI와 동일) |
+
+`/` 입력 시 `/super`로 필터 가능 · `deliver=agent`로 작업 지시가 에이전트 턴에 전달됩니다.
+
 ## 라이선스
 
 Apache-2.0
@@ -128,6 +142,20 @@ cluxion-supercoder doctor --json   # structured output
 
 Also exposed inside Hermes as the `supercoder_doctor` tool.
 
+## Hermes slash commands (0.2.15+)
+
+```
+/supercoder fix failing auth tests and run gates
+/supercoder-doctor
+```
+
+| Slash | Purpose |
+|---|---|
+| `/supercoder <task>` | Supercoder coding mode — plan + repo map sent to the agent |
+| `/supercoder-doctor` | Run doctor (same as CLI) |
+
+Filter with `/super` · uses `deliver=agent` so the harness directive becomes the next agent turn.
+
 ## License
 
 Apache-2.0

{cluxion_agentplugin_supercoder-0.2.14 → cluxion_agentplugin_supercoder-0.2.15}/README.md

@@ -50,6 +50,20 @@ cluxion-supercoder doctor --json   # 구조화 출력
 
 Hermes 안에서는 `supercoder_doctor` 도구로도 노출됩니다.
 
+## Hermes 슬래시 커맨드 (0.2.15+)
+
+```
+/supercoder fix failing auth tests and run gates
+/supercoder-doctor
+```
+
+| 슬래시 | 용도 |
+|---|---|
+| `/supercoder <task>` | 슈퍼코더 코딩 모드 — plan + repo map을 에이전트에 전달 |
+| `/supercoder-doctor` | doctor (CLI와 동일) |
+
+`/` 입력 시 `/super`로 필터 가능 · `deliver=agent`로 작업 지시가 에이전트 턴에 전달됩니다.
+
 ## 라이선스
 
 Apache-2.0
@@ -105,6 +119,20 @@ cluxion-supercoder doctor --json   # structured output
 
 Also exposed inside Hermes as the `supercoder_doctor` tool.
 
+## Hermes slash commands (0.2.15+)
+
+```
+/supercoder fix failing auth tests and run gates
+/supercoder-doctor
+```
+
+| Slash | Purpose |
+|---|---|
+| `/supercoder <task>` | Supercoder coding mode — plan + repo map sent to the agent |
+| `/supercoder-doctor` | Run doctor (same as CLI) |
+
+Filter with `/super` · uses `deliver=agent` so the harness directive becomes the next agent turn.
+
 ## License
 
 Apache-2.0

{cluxion_agentplugin_supercoder-0.2.14 → cluxion_agentplugin_supercoder-0.2.15}/adapters/hermes/README.md

@@ -8,4 +8,13 @@ cluxion-supercoder check
 
 Tools: `supercoder_plan`, `supercoder_read_window`, `supercoder_patch`, `supercoder_cursor_map`, `supercoder_test_gate`, `supercoder_brief`
 
-연결된 AI가 코딩 task에서 위 도구를 순서대로 호출합니다.
+연결된 AI가 코딩 task에서 위 도구를 순서대로 호출합니다.
+
+## 슬래시 (0.2.15+)
+
+```
+/supercoder <task>        # 코딩 모드 — plan + 패치/게이트 워크플로우 지시
+/supercoder-doctor
+```
+
+`/` 입력 시 `/super`로 필터 · `/supercoder`는 에이전트 턴으로 전달(`deliver=agent`).

{cluxion_agentplugin_supercoder-0.2.14 → cluxion_agentplugin_supercoder-0.2.15}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "cluxion-agentplugin-supercoder"
-version = "0.2.14"
+version = "0.2.15"
 description = "Universal agent coding harness plugin: cursor logic, safe patch, line budget, Rust index, test gates."
 readme = "README.md"
 requires-python = ">=3.11"

cluxion_agentplugin_supercoder-0.2.15/rust/supercoder_index/uv.lock

@@ -0,0 +1,8 @@
+version = 1
+revision = 3
+requires-python = ">=3.11"
+
+[[package]]
+name = "supercoder-index-native"
+version = "0.2.0"
+source = { editable = "." }

{cluxion_agentplugin_supercoder-0.2.14 → cluxion_agentplugin_supercoder-0.2.15}/src/cluxion_agentplugin_supercoder/plugin.py

@@ -16,6 +16,7 @@ from cluxion_agentplugin_supercoder.schemas import (
     SYNTAX_GATE_SCHEMA,
     TEST_GATE_SCHEMA,
 )
+from cluxion_agentplugin_supercoder.slash_commands import handle_supercoder
 
 
 def register(ctx: object) -> None:
@@ -116,10 +117,20 @@ def register(ctx: object) -> None:
     register_command = getattr(ctx, "register_command", None)
     if callable(register_command):
 
+        def _slash_supercoder(raw_args: str) -> str:
+            return handle_supercoder(raw_args, ctx)
+
         def _slash_supercoder_doctor(raw_args: str) -> str:
             del raw_args
             return _handle_supercoder_doctor({})
 
+        register_command(
+            "supercoder",
+            _slash_supercoder,
+            description="Supercoder coding mode — plan, verified patches, test gates",
+            args_hint="<task>",
+            deliver="agent",
+        )
         register_command(
             "supercoder-doctor",
             _slash_supercoder_doctor,

cluxion_agentplugin_supercoder-0.2.15/src/cluxion_agentplugin_supercoder/slash_commands.py

@@ -0,0 +1,73 @@
+"""Hermes slash commands for supercoder (/supercoder, /supercoder-doctor)."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from cluxion_agentplugin_supercoder import runner
+
+SUPERCODER_HELP = """\
+/supercoder <task> — Enter supercoder coding mode
+
+Runs supercoder_plan and sends a coding harness directive to the agent.
+
+Workflow the agent must follow:
+  supercoder_plan → supercoder_read_window → supercoder_patch
+  → supercoder_syntax_gate → supercoder_lint_gate → supercoder_test_gate → supercoder_brief
+
+Examples:
+  /supercoder fix failing auth tests in src/auth/
+  /supercoder add pagination to the users API with tests
+
+Notes:
+  - Patches are hash-verified; empty old_text is rejected immediately
+  - Repo map is attached to the plan when available
+  - Diagnostics: /supercoder-doctor
+"""
+
+
+def build_supercoder_directive(task: str, plan_payload: dict[str, object]) -> str:
+    plan_block = json.dumps(plan_payload, ensure_ascii=False, indent=2)
+    return (
+        "[SUPERCODER MODE]\n"
+        "Use the supercoder toolset for all code changes in this task.\n\n"
+        f"Task: {task}\n\n"
+        "Required sequence:\n"
+        "1. Use the supercoder_plan result below (do not skip repo_map)\n"
+        "2. supercoder_read_window before each edit\n"
+        "3. supercoder_patch only with verified old_text hashes\n"
+        "4. supercoder_syntax_gate → supercoder_lint_gate → supercoder_test_gate after edits\n"
+        "5. supercoder_brief with files_changed, tests_run, verification_status\n\n"
+        f"supercoder_plan:\n{plan_block}"
+    )
+
+
+def handle_supercoder(raw_args: str, ctx: object | None = None) -> str:
+    del ctx  # Hermes deliver=agent routes the return value to the agent turn
+    task = raw_args.strip()
+    if not task or task.lower() in {"help", "-h", "--help"}:
+        return SUPERCODER_HELP
+    try:
+        result = runner.plan({"prompt": task, "cwd": str(Path.cwd())})
+        payload = json.loads(result.to_json())
+        if not payload.get("ok"):
+            return f"supercoder error: {payload.get('error', 'plan failed')}"
+        body = payload.get("result", payload)
+        if not isinstance(body, dict):
+            body = {"plan": body}
+        if body.get("mode") == "bypass":
+            return (
+                f"supercoder: not a coding task ({body.get('reason', 'bypass')}).\n"
+                "Rephrase as a concrete code change request."
+            )
+        return build_supercoder_directive(task, body)
+    except Exception as exc:
+        return f"supercoder error: {exc}"
+
+
+__all__ = [
+    "SUPERCODER_HELP",
+    "build_supercoder_directive",
+    "handle_supercoder",
+]

{cluxion_agentplugin_supercoder-0.2.14 → cluxion_agentplugin_supercoder-0.2.15}/tests/test_plugin.py

@@ -11,12 +11,23 @@ def test_register_exposes_all_tools() -> None:
     class FakeCtx:
         def __init__(self):
             self.tools = {}
+            self.commands = {}
 
         def register_tool(self, name, toolset=None, schema=None, handler=None, emoji=None):
             self.tools[name] = {"toolset": toolset, "schema": schema}
 
+        def register_command(self, name, handler, description="", args_hint="", deliver="output"):
+            self.commands[name] = {
+                "handler": handler,
+                "description": description,
+                "args_hint": args_hint,
+                "deliver": deliver,
+            }
+
     ctx = FakeCtx()
     plugin.register(ctx)
+    assert "supercoder" in ctx.commands
+    assert "supercoder-doctor" in ctx.commands
     assert sorted(ctx.tools) == [
         "supercoder_brief",
         "supercoder_cursor_map",

cluxion_agentplugin_supercoder-0.2.15/tests/test_slash_commands.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+import json
+
+from cluxion_agentplugin_supercoder.slash_commands import (
+    SUPERCODER_HELP,
+    build_supercoder_directive,
+    handle_supercoder,
+)
+
+
+def test_supercoder_help_without_args() -> None:
+    assert "supercoder_plan" in handle_supercoder("")
+    assert handle_supercoder("help") == SUPERCODER_HELP
+
+
+def test_build_directive_includes_task() -> None:
+    body = {"mode": "coding_queue", "units": [{"id": "u1", "goal": "fix tests"}]}
+    text = build_supercoder_directive("fix auth tests", body)
+    assert "[SUPERCODER MODE]" in text
+    assert "fix auth tests" in text
+    assert "supercoder_plan" in text
+
+
+def test_handle_supercoder_bypass(tmp_path, monkeypatch) -> None:
+    monkeypatch.chdir(tmp_path)
+    out = handle_supercoder("what is the weather today?")
+    assert "not a coding task" in out
+
+
+def test_handle_supercoder_returns_directive(tmp_path, monkeypatch) -> None:
+    monkeypatch.chdir(tmp_path)
+    (tmp_path / "a.py").write_text("x=1\n", encoding="utf-8")
+    out = handle_supercoder("refactor a.py and fix the failing unit tests")
+    assert "[SUPERCODER MODE]" in out
+    plan = json.loads(out.split("supercoder_plan:\n", 1)[1])
+    assert plan.get("mode") == "coding_queue"

{cluxion_agentplugin_supercoder-0.2.14 → cluxion_agentplugin_supercoder-0.2.15}/uv.lock

@@ -160,7 +160,7 @@ wheels = [
 
 [[package]]
 name = "cluxion-agentplugin-supercoder"
-version = "0.2.14"
+version = "0.2.15"
 source = { editable = "." }
 dependencies = [
     { name = "psutil" },