@mutmutco/codex-plugin 3.139.0 → 3.139.1

package/scripts/validate-hook.mjs

@@ -1,156 +0,0 @@
-// PreToolUse validate-hook (#2691): catch a bad mmi-cli WRITE before it spends a failed round-trip.
-// When a Bash/PowerShell tool call is a simple `mmi-cli <verb> ...` invocation, this re-runs the SAME
-// command with `--validate-only` (C3 middleware — a PURE LOCAL parse + flag/enum/ref check that writes
-// NOTHING and never hits the network) against the shipped bundle. A validation failure surfaces as an
-// ADVISORY (warn to stderr, never a deny) so the agent fixes the flags before the real write.
-//
-// FAST + FAIL-OPEN by contract: it only spawns for a detected simple mmi-cli command (never for general
-// shell), skips any compound/piped/redirected command (too risky to reconstruct), bounds the spawn with a
-// short timeout, and swallows every error — a validate probe must never block or slow a tool call it can't
-// help. Disabled by default (opt-in): enable with MMI_VALIDATE_HOOK=on.
-import { execFileSync } from 'node:child_process';
-import { existsSync } from 'node:fs';
-import { dirname, join, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { tokenizeShell } from './command-ladder-core.mjs';
-import { appendHookActivity } from './hook-trace.mjs';
-
-const SPAWN_TIMEOUT_MS = 6000;
-const MMI_BINARIES = new Set(['mmi-cli', 'mmi', 'mmi-cli.cmd', 'mmi.cmd']);
-const WRAPPER_TOKENS = new Set(['command', 'sudo', 'npx']);
-// Any of these in the raw command means it is not a single simple invocation — skip (do not reconstruct).
-const SHELL_META_RE = /[|&;`]|\$\(|[<>]|\|\||&&/;
-
-/** Strip one layer of matching surrounding quotes from a token so it becomes a real argv value. */
-function unquote(tok) {
-  if (tok.length >= 2 && ((tok[0] === '"' && tok.at(-1) === '"') || (tok[0] === "'" && tok.at(-1) === "'"))) {
-    return tok.slice(1, -1);
-  }
-  return tok;
-}
-
-/**
- * Detect a single, simple `mmi-cli <args...>` invocation and return its argv (quote-stripped), or null.
- * Conservative by design: rejects any command carrying shell metacharacters (pipes, redirects, compounds,
- * substitutions) so we never mis-reconstruct a complex command. Tolerates leading `command`/`sudo`/`npx`
- * wrappers and inline `VAR=val` assignments. Exported (pure) for tests.
- * @param {string} command
- * @returns {{ argv: string[] } | null}
- */
-export function detectMmiCliCommand(command) {
-  if (!command || typeof command !== 'string') return null;
-  if (SHELL_META_RE.test(command)) return null;
-  const tokens = tokenizeShell(command);
-  let i = 0;
-  while (i < tokens.length && (WRAPPER_TOKENS.has(tokens[i]) || /^[A-Za-z_][\w]*=/.test(tokens[i]))) i += 1;
-  const bin = tokens[i];
-  if (!bin || !MMI_BINARIES.has(bin.toLowerCase())) return null;
-  const argv = tokens.slice(i + 1).map(unquote);
-  if (!argv.length) return null; // bare `mmi-cli` with no verb — nothing to validate
-  // `--validate-only` already present ⇒ the agent is deliberately dry-running; don't double up.
-  if (argv.includes('--validate-only') || argv.includes('--dry-run')) return null;
-  return { argv };
-}
-
-/**
- * Interpret a `--validate-only` spawn result into an advisory line, or null (silent). Pure + testable.
- *  - stdout `{ok:true,...}`  → the command validates → silent.
- *  - stderr "unknown option/command" → not a mutating/known command (validate not applicable) → silent.
- *  - non-zero exit otherwise → a real validation problem the write would hit → advise with the message.
- * @param {{ status: number|null, stdout: string, stderr: string }} res
- * @returns {string | null}
- */
-export function interpretValidateResult(res) {
-  const stdout = String(res?.stdout ?? '').trim();
-  const stderr = String(res?.stderr ?? '').trim();
-  if (stdout.startsWith('{')) {
-    try {
-      if (JSON.parse(stdout).ok === true) return null; // validates cleanly
-    } catch {
-      /* fall through — non-JSON stdout is not a success signal */
-    }
-  }
-  if (/unknown option|unknown command/i.test(stderr)) return null; // validate not applicable to this command
-  if (res?.status && res.status !== 0) {
-    const firstLine = (stderr.split(/\r?\n/).find((l) => l.trim()) ?? stdout.split(/\r?\n/)[0] ?? '').trim();
-    return firstLine || null;
-  }
-  return null;
-}
-
-/** Resolve the shipped CLI bundle path: explicit override, then the plugin root, then a path relative to
- *  this script (repo layout: scripts/ and cli/ are siblings). Returns null when none exists. */
-function resolveBundle(env) {
-  const candidates = [];
-  if (env.MMI_CLI_BUNDLE) candidates.push(env.MMI_CLI_BUNDLE);
-  if (env.CLAUDE_PLUGIN_ROOT) candidates.push(join(env.CLAUDE_PLUGIN_ROOT, 'cli', 'dist', 'index.cjs'));
-  candidates.push(resolve(dirname(fileURLToPath(import.meta.url)), '..', 'cli', 'dist', 'index.cjs'));
-  return candidates.find((p) => existsSync(p)) ?? null;
-}
-
-/**
- * Run the validate advisory for a PreToolUse Bash/PowerShell input. IO-thin: gating + one guarded spawn.
- * Injected `spawnFn` and `bundleResolver` keep it unit-testable without the real bundle.
- */
-export function runValidateAdvisory(input, { stderr = process.stderr, env = process.env, spawnFn, bundleResolver = resolveBundle } = {}) {
-  // Default OFF (opt-in): the advisory spawns a ~150-400ms bundle on write-shaped mmi-cli calls, above the
-  // "tens of ms" hook budget, so it stays out of the hot path unless explicitly enabled with MMI_VALIDATE_HOOK=on.
-  if (String(env.MMI_VALIDATE_HOOK ?? '').toLowerCase() !== 'on') return { ran: false };
-  const tool = input?.tool_name;
-  if (tool !== 'Bash' && tool !== 'PowerShell') return { ran: false };
-
-  const detected = detectMmiCliCommand(input?.tool_input?.command);
-  if (!detected) return { ran: false };
-
-  const bundle = bundleResolver(env);
-  if (!bundle) return { ran: false };
-
-  let res;
-  try {
-    const run = spawnFn ?? ((args) => {
-      const r = execFileSync(process.execPath, [bundle, ...args], {
-        encoding: 'utf8',
-        stdio: ['ignore', 'pipe', 'pipe'],
-        timeout: SPAWN_TIMEOUT_MS,
-        windowsHide: true,
-        env: { ...env, MMI_VALIDATE_HOOK: 'off' }, // guard against any re-entrant hook
-      });
-      return { status: 0, stdout: r, stderr: '' };
-    });
-    res = run([...detected.argv, '--validate-only']);
-  } catch (e) {
-    // execFileSync throws on a non-zero exit — that carries the validation failure on stdout/stderr.
-    if (e && (e.stdout !== undefined || e.stderr !== undefined)) {
-      res = { status: e.status ?? 1, stdout: String(e.stdout ?? ''), stderr: String(e.stderr ?? '') };
-    } else {
-      appendHookActivity({ event: 'PreToolUse', script: 'validate-hook', outcome: 'failed', action: 'spawn error', tool });
-      return { ran: false }; // spawn/timeout error — fail-open, silent
-    }
-  }
-
-  const advice = interpretValidateResult(res);
-  appendHookActivity({
-    event: 'PreToolUse',
-    script: 'validate-hook',
-    outcome: advice ? 'observe' : 'ran',
-    action: advice ? advice.slice(0, 200) : 'valid',
-    tool,
-  });
-  if (advice) {
-    stderr.write(`[mmi-validate] --validate-only flagged this command before it runs: ${advice}\n`);
-    stderr.write('[mmi-validate] advisory only — fix the flags/enums above, or proceed if this is intended.\n');
-  }
-  return { ran: true, advised: Boolean(advice) };
-}
-
-if (
-  process.argv[1] &&
-  (process.argv[1].endsWith('validate-hook.mjs') ||
-    process.argv[1].replace(/\\/g, '/').endsWith('scripts/validate-hook.mjs'))
-) {
-  import('./hook-io.mjs')
-    .then(({ readHookInput }) => readHookInput())
-    .then((input) => runValidateAdvisory(input))
-    .catch(() => undefined)
-    .finally(() => process.exit(0));
-}

package/skills/worktree/SKILL.md

@@ -1,151 +0,0 @@
----
-name: worktree
-description: Orchestrate a worktree from create to landed PR, tied to board status.
----
-
-**Host-native invocation:** Claude `/mmi:worktree` · Codex `$mmi:worktree` · jervcode/Kimi `/skill:worktree` · Kilo `skill` tool. A backticked `/name` in this doc names the matching workflow (this skill or a sibling), not a literal command.
-
-# /worktree — create → work → land
-
-Drive an item through an isolated worktree: cut it from latest `development`, claim the board item, do the
-work, open and land the PR, and clean up — with the board moving automatically at each boundary. One
-worktree per session; everything under `../mmi-worktrees/` is ephemeral and sweepable.
-
-## Step 1 — create + provision
-
-```bash
-mmi-cli worktree create <owner/repo#N> --claim --from origin/development
-```
-
-`worktree create` cuts the branch from `origin/development` (fetched first) and provisions it: installs
-deps (`npm ci`) and copies local-only config (`.claude/settings.local.json`) a fresh checkout lacks. Use
-`--from <ref>` for a non-default base, `--path <path>` to override the location. An existing worktree that
-lost its deps re-provisions with `mmi-cli worktree setup [path]` (the SessionStart hook fires this
-automatically).
-
-The issue-ref form derives `<issue-number>-<short-slug>`, assigns the item, and moves it to In Progress.
-
-`worktree create` also leases the tree to the **creating session** (#4328). A later `jerv-cli lane submit
---dir` (or any governed seat) refuses an already-held host lease and will not commandeer it. Before handing
-the tree to a governed seat, release that lease first — safe once the session's own edits in that tree are
-committed and pushed: `jerv-cli lease close --ref <worktree path>` (closes every lease on that ref; no id
-lookup needed). To inspect what's held before closing, `jerv-cli lease list` shows id, ref, and owner.
-
-## Step 2 — claim + work
-
-Work in the provisioned worktree. Exercise the change with `/stage` (a local stage is bound to the worktree that
-started it — stop it before switching worktrees). Sequential related items in one session reuse the active
-worktree; do not churn one worktree per issue unless a true parallel or PR boundary needs it.
-
-## Step 3 — open the PR
-
-Push the branch and open the PR against `development`. The board moves to In Review automatically on PR
-open — never move it by hand.
-
-```bash
-git push origin <branch>:<branch>              # explicit feature refspec — see below
-mmi-cli devops pr create --title "<title>" --body-file .jerv/PR_BODY.md --base development
-mmi-cli devops pr checks-wait <PR-number>              # wait for required CI to go green
-```
-
-Write the PR body under `.jerv/` (#4405), never at the worktree root. `.jerv/` is the agent-artifact
-prefix `worktree land` treats as removable; a stray untracked `PR_BODY.md` anywhere else classifies the
-tree as `untracked-files` and Step 4 then skips cleanup entirely.
-
-The push must be the explicit `<branch>:<branch>` refspec (the branch Step 1 derived, e.g.
-`git push origin 3795-my-slice:3795-my-slice`). The #1660 protected-push gate denies the
-`HEAD`/remote-only form (`git push -u origin HEAD`) — its target cannot be proven safe. And never
-share the push with staging or commit verbs in one compound command: the deny applies to the whole
-command, so a refused `git add … && git commit … && git push …` chain discards the add and commit
-with it. Stage, commit, and push as separate commands.
-
-If the branch adds, removes, or renames any `docs/` file, `pr create` refuses with a stale
-`docs/index.md` (#4092) — run `mmi-cli oracle docs index --write`, commit `docs/index.md`, and push again
-before retrying.
-
-## Step 4 — land + clean up
-
-Under standing go (green CI, CI-gated PR) land to `development`. **Invoke `mmi-cli devops pr land` from the
-primary checkout** (or any cwd that is not the PR worktree) (#4549). Landing while cwd is still inside
-the worktree that cleanup removes can merge successfully and still exit 1 with
-`cleanupError: … Unable to read current working directory` — post-merge `gh`/`git` follow-ups then have
-no readable cwd even when removal itself chdir'd away (#4140).
-
-```bash
-cd <primary-checkout>   # e.g. the main MMI-Hub clone — not the slice worktree
-mmi-cli devops pr land <PR-number>
-```
-
-`pr land` waits for checks, squash-merges, and does the full cleanup at the branch boundary: removes the
-worktree, deletes the merged branch (local + origin), and prunes tracking refs. A worktree the IDE has
-locked is queued and retried by `mmi-cli worktree gc sweep-deferred`. Self-authored merges need an explicit
-per-session merge grant — ask early if you don't have one.
-
-**`not-attempted (untracked-files)` (#3500 / #4405):** the usual cause of a merged PR that left its
-worktree behind. Any untracked path outside `.jerv/` — a hand-written `PR_BODY.md`, notes, a scratch
-script — makes removal refuse, because an unadded file can be real work. Delete or move the file, then
-re-run cleanup **from inside the worktree** (`worktree land` has no `--path`; it acts on the tree you
-are standing in):
-
-```bash
-mmi-cli worktree land --apply
-```
-
-**Cwd-safe removal (#4140):** `worktree land --apply` (what `pr land` runs) releases the process cwd to
-the primary checkout before deleting the tree (#1444/#2747) so Windows `rmdir` is not `EBUSY`. That does
-**not** replace the agent rule above: still start `pr land` from the primary checkout (#4549). Prefer
-primary cwd also when running `worktree land` manually outside `pr land`. If removal still fails (IDE
-lock, antivirus), the deferred sweep retries from a safe cwd.
-
-**No main lineage on a squashable development PR (#4365 / #4371):** never `git merge -s ours` (or otherwise
-merge) a main-parented port commit into a development PR that will squash. Squash folds second-parent
-trailers — including foreign `Closes #N` — into the development squash body, closes the wrong issues, and
-trips the closing-keyword land guard. Keep the cherry-pick / main-clean source on a separate branch or ref;
-land only development-tree changes on the development PR. To record a pushed main-clean SHA for a later
-`/hotfix --from` without polluting squash parents, prefer a marker-only commit on the development branch
-that references that SHA in the message — do not pull the main commit into the squashable parent list.
-This does not weaken the `#3167` merge floor on `/hotfix` and `/release` (never squash a tagged commit;
-alignment / roll-forward stays a true merge).
-
-**Stay-open phrasing (JC#495 / #3718):** GitHub's closing-keyword parser is negation-blind. `Does not
-close #N` still contains `close #N` and **closes the issue** on merge/squash (measured: Jerv-JervCode
-PR #493 closed #487). When an issue must stay open, never put `close`/`closes`/`fix`/`resolve` + `#N`
-in the PR body, commit message, or merge message — use `Part of #N`, `Refs #N`, or `leaves #N open` only.
-`mmi-cli devops pr create` rewrites common negated phrases; `pr land` / `pr merge` still refuse any remaining
-negation-blind close. `--force` only when those targets should actually close.
-
-If a PR already inherited closed-issue `Closes` keywords from that anti-pattern and `pr land` / `pr merge`
-refuses, land with `--force` only when those inherited targets are already closed — prefer preventing the
-pollution above over relying on `--force`.
-
-## Step 5 — record + next
-
-Record durable decisions on the issue or PR, then check the board again:
-
-```bash
-mmi-cli oracle wave status        # remaining worktrees, open PRs, local stages at a glance
-mmi-cli oracle next               # the next actionable item
-```
-
-## Notes
-
-- Cut worktrees only at `../mmi-worktrees/<RepoName>/<branch>` (#3471) — generic helpers that force `.claude/worktrees/` or
-  `.worktrees/` are not the MMI path.
-- Multiple independent items → one worktree each, run in parallel, one PR per item (`/mmi` Leverage).
-- Never land to a protected/release branch here — that is `/rcand` and `/release`.
-- **Keep Cursor on the primary checkout (#4489 / #4901).** Edit the worktree without
-  `move_agent_to_root` into the slice — moving the workspace root pins the session so land/gc
-  refuse forever. If Cursor’s agent workspace is still rooted at the slice, `worktree land` /
-  `worktree gc --apply` / doctor gc **refuse** to delete that directory (and queue deferred
-  removal). On a Cursor agent host, land/gc fail closed when the active root cannot be resolved:
-  open the primary first, or set `MMI_ACTIVE_WORKSPACE_ROOT` to the primary path. After Cursor is
-  on the primary, `mmi-cli worktree gc sweep-deferred` finishes cleanup.
-
-## Retro — one check before you finish
-Before your final report, answer one question honestly: did **this skill's own instructions** misfire
-this run — ambiguous wording, a misleading message, or an environment failure it should have warned
-about? (Process only — never the user's code or task; e.g. a create that branched from a stale base, or a
-land that left a worktree behind.) If yes, file **one** lesson and move on; a clean run is silent (hard
-cap: one per run). It lands on the Hub board (deduped) and is fixed only via a reviewed PR — never edit
-the skill live; the retro is advisory, so if the call fails, note it and continue:
-`mmi-cli learning skill-lesson --skill worktree --title "<what misfired>" --body "<what; evidence; proposed amendment>"`