@zhixuan92/multi-model-agent 3.6.5 → 3.6.7

package/README.md

@@ -82,7 +82,7 @@ Two ways — pick one:
 
 ```bash
 mmagent serve                          # 127.0.0.1:7337 by default
-curl -s http://localhost:7337/health   # → {"ok":true,"version":"3.6.5",...}
+curl -s http://localhost:7337/health   # → {"ok":true,"version":"3.6.7",...}
 ```
 
 For an always-on background install (survives reboots): [launchd / systemd templates](./scripts/README.md).
@@ -237,7 +237,7 @@ Full design rationale: [DIRECTION.md](https://github.com/zhixuan312/multi-model-
 
 ## What's new
 
-Latest: **3.6.5** — Intake classifier no longer flags ordinary technical English ("publish docs", "send a request", "telemetry system") as needing clarification. Genuine destructive prompts (`rm -rf`, `drop table`, `force push`, `deploy to prod`, ...) still flag. Full history: [CHANGELOG](https://github.com/zhixuan312/multi-model-agent/blob/master/CHANGELOG.md).
+Latest: **3.6.7** — Telemetry is now permissive on model/client/tool/skill identifiers: schema validates *shape, not vocabulary*. Anthropic 4.x, OpenAI o-series, Bedrock vendor prefixes, OpenRouter `meta-llama/...`, Ollama `llama2:7b`, custom finetunes, MCP tool names from any server — all pass through unchanged instead of being rejected or collapsed to `'other'`. `ModelFamily` enum widened 5 → 12 (added `grok`, `mistral`, `meta`, `qwen`, `zhipu`, `kimi`, `minimax`); `allowlistModel` renamed to `normalizeModelForTelemetry`. Full history: [CHANGELOG](https://github.com/zhixuan312/multi-model-agent/blob/master/CHANGELOG.md).
 
 ## Full documentation
 

package/dist/skills/mma-audit/SKILL.md

@@ -2,15 +2,13 @@
 name: mma-audit
 description: >-
   Use when the user asks to audit a document, spec, config, or PR description
-  for security, correctness, performance, or style issues — and the audit can
-  run in parallel per file with no context pollution
+  for security, correctness, performance, or style issues — and 2+ files need
+  independent audit passes
 when_to_use: >-
   User asks for a doc/spec/config audit OR a methodology skill
   (superpowers:dispatching-parallel-agents, /security-review) points at one AND
-  mmagent is running. Delegate so each file audits on its own worker; the main
-  agent only synthesizes findings. Audit on PROSE/SPEC docs — use mma-review for
-  source code.
-version: 3.6.5
+  mmagent is running. Audit on PROSE/SPEC docs — use mma-review for source code.
+version: 3.6.7
 ---
 
 # mma-audit
@@ -74,6 +72,14 @@ BATCH_ID=$(echo "$BATCH" | jq -r '.batchId')
 
 @include _shared/response-shape.md
 
+## Best practices
+
+This skill is one step in the larger flow described in `multi-model-agent` → "Best practices". Recipes that involve `mma-audit`:
+
+- **Recipe A — Audit-iterate-clean.** `mma-audit` → fix → `mma-audit` again. Sequential rounds. Register the doc via `mma-context-blocks` before round 1 and reuse the same ID across all rounds — avoids re-inlining the same content into every audit call.
+
+Anti-pattern alert: **`parallel-rounds-same-target`** (AP1). Three parallel audits on the same document re-flag the same issues without seeing each other's fixes. Run rounds sequentially with a fix between each.
+
 ## Common pitfalls
 
 ❌ **Auditing source code with `mma-audit`**

package/dist/skills/mma-clarifications/SKILL.md

@@ -8,8 +8,11 @@ when_to_use: >-
   A previous mma-delegate / mma-audit / mma-review / mma-execute-plan /
   mma-debug / mma-investigate terminal envelope has `proposedInterpretation` as
   a string. Read the proposal, decide whether to accept or correct it, then call
-  this skill. The batch resumes immediately after the POST returns.
-version: 3.6.5
+  this skill. The batch resumes immediately after the POST returns. A string
+  `proposedInterpretation` is a hard gate — the batch is paused, not
+  informational. The batch will not complete until the caller responds. Treating
+  it as advisory is the clarification-as-info anti-pattern (AP5).
+version: 3.6.7
 ---
 
 # mma-clarifications
@@ -103,6 +106,12 @@ curl -f --show-error -s -X POST \
 
 @include _shared/polling.md
 
+## Best practices
+
+This skill is described in `multi-model-agent` → "Best practices". Clarification resumption is a universal flow — it triggers whenever any batch enters `awaiting_clarification`, regardless of which recipe produced the batch. There is no per-recipe entry to call out.
+
+Anti-pattern alert: **`clarification-as-info`** (AP5). A string `proposedInterpretation` is a hard gate, not an FYI. The batch will not complete until the caller responds. Either accept the proposal verbatim or correct it.
+
 ## Common pitfalls
 
 ❌ **Confirming a wrong proposal verbatim because "the service knows best"**

package/dist/skills/mma-context-blocks/SKILL.md

@@ -3,14 +3,16 @@ name: mma-context-blocks
 description: >-
   Use when a document larger than ~2 KB will be referenced by 2+ subsequent
   mma-* calls — register once, pass the returned ID to each call instead of
-  re-uploading the same content
+  re-uploading the same content. OR a spec / plan / error log was already
+  inlined into one task and is about to be inlined into a second — register on
+  the second reference, never the third.
 when_to_use: >-
   A document (spec, plan, codebase summary, prior round's findings, error log)
   larger than ~2 KB will be referenced by two or more mma-* calls in a row.
   Register once here, then pass the ID via `contextBlockIds` on mma-delegate /
   mma-execute-plan / mma-audit / mma-review / mma-verify / mma-debug /
   mma-investigate. Cheaper and faster than inlining the same content N times.
-version: 3.6.5
+version: 3.6.7
 ---
 
 # mma-context-blocks
@@ -91,6 +93,17 @@ curl -f --show-error -s -X POST \
   "http://localhost:$PORT/delegate?cwd=/project"
 ```
 
+## Best practices
+
+This skill is the cross-cutting state mechanism described in `multi-model-agent` → "Best practices". Recipes that use context blocks:
+
+- **Recipe A — Audit-iterate-clean.** Register the doc once before round 1; pass round-N's findings block ID into round N+1.
+- **Recipe B — Debug-fix-verify.** Register the failing test output / reproduction log before the debug call; reuse on verify.
+- **Recipe C — Investigate-plan-execute.** Register the plan file before `mma-execute-plan`.
+- **Recipe D — Plan-execute-retry.** No new registration needed — `mma-retry` inherits the original batch's `contextBlockIds`.
+
+Anti-pattern alert: **`re-inlined-shared-content`** (AP3). Pasting the same spec into 5 task prompts costs N× tokens. Register once; pass `contextBlockIds`.
+
 ## Common pitfalls
 
 ❌ **Inlining the same 50KB spec into every task prompt**

package/dist/skills/mma-debug/SKILL.md

@@ -10,7 +10,7 @@ when_to_use: >-
   read files, reproduce, trace — OR a methodology skill
   (superpowers:systematic-debugging) points at the investigation step. Delegate
   the read/reproduce/trace; the main agent stays on the hypothesis and the fix.
-version: 3.6.5
+version: 3.6.7
 ---
 
 # mma-debug
@@ -78,6 +78,14 @@ BATCH_ID=$(echo "$BATCH" | jq -r '.batchId')
 
 @include _shared/response-shape.md
 
+## Best practices
+
+This skill is one step in the larger flow described in `multi-model-agent` → "Best practices". Recipes that involve `mma-debug`:
+
+- **Recipe B — Debug-fix-verify.** `mma-debug` → `mma-delegate` (apply fix) → `mma-verify`. Strict order. Register the failing test output / reproduction log as a context block before the debug call; reuse on verify.
+
+Anti-pattern alert: **`inline-labor-leakage`** (AP2). If you're about to read 3+ files in main context to "understand the bug," that's the labor we delegate — call `mma-debug` with the hypothesis instead.
+
 ## Common pitfalls
 
 ❌ **Vague `problem`**
@@ -92,9 +100,9 @@ The worker explores blindly, often investigates the wrong area first. **Fix:** e
 Debug intentionally bundles `filePaths` for cross-file reasoning. Splitting defeats this. **Fix:** one call with all suspect files; if you really have N independent failures, use `mma-delegate` with N tasks.
 
 ❌ **Treating `mma-debug` as the fix step**
-Debug investigates and proposes; it doesn't necessarily write the fix. If the worker identifies a fix, dispatch `mma-delegate` to implement it (or write it inline if you understand it).
+Debug investigates and proposes; it doesn't necessarily write the fix. **Fix:** if the worker identifies a fix, dispatch `mma-delegate` to implement it (or write it inline if you understand it).
 
 ❌ **Skipping when an error message looks self-explanatory**
-Often the obvious cause isn't the real one. A 30-second debug pass costs less than a wrong fix that breaks something else.
+Often the obvious cause isn't the real one. **Fix:** a 30-second debug pass costs less than a wrong fix that breaks something else.
 
 @include _shared/error-handling.md

package/dist/skills/mma-delegate/SKILL.md

@@ -11,14 +11,14 @@ when_to_use: >-
   and keep main context free. If a plan file exists → use mma-execute-plan. If
   the task is audit / review / verify / debug / investigate → use the matching
   specialized skill.
-version: 3.6.5
+version: 3.6.7
 ---
 
 # mma-delegate
 
 ## Overview
 
-Dispatch one or more ad-hoc tasks to sub-agents concurrently. Each task is an independent instruction with optional file scope, acceptance criteria, and context blocks.
+Dispatch one or more ad-hoc tasks to workers concurrently. Each task is an independent instruction with optional file scope, acceptance criteria, and context blocks.
 
 **Core principle:** Workers run on cheap providers; the main agent consumes only the structured per-task report. Parallelize freely as long as tasks don't write the same files.
 
@@ -85,6 +85,15 @@ BATCH_ID=$(echo "$BATCH" | jq -r '.batchId')
 
 @include _shared/response-shape.md
 
+## Best practices
+
+This skill is one step in the larger flow described in `multi-model-agent` → "Best practices". Recipes that involve `mma-delegate`:
+
+- **Recipe A (the fix step).** Between audit rounds, `mma-delegate` applies the fix when the change is more than 1-2 lines. Register the spec/audit findings as a context block; pass via `contextBlockIds`.
+- **Recipe B (the apply-fix step).** After `mma-debug` returns a hypothesis, `mma-delegate` applies the fix. Same context block carries forward to `mma-verify`.
+
+Anti-pattern alert: **`inline-labor-leakage`** (AP2). If you're reading 3+ files or grepping in main context before dispatching, you're paying flagship-model tokens for labor. Pass the file paths to `mma-delegate` and let the worker read.
+
 ## Common pitfalls
 
 ❌ **Two tasks writing the same file in one batch**

package/dist/skills/mma-execute-plan/SKILL.md

@@ -10,7 +10,7 @@ when_to_use: >-
   superpowers:subagent-driven-development / superpowers:executing-plans —
   workers are cheaper and don't pollute main context. Task descriptors must
   match plan headings verbatim.
-version: 3.6.5
+version: 3.6.7
 ---
 
 # mma-execute-plan
@@ -86,6 +86,15 @@ BATCH_ID=$(echo "$BATCH" | jq -r '.batchId')
 
 @include _shared/response-shape.md
 
+## Best practices
+
+This skill is one step in the larger flow described in `multi-model-agent` → "Best practices". Recipes that involve `mma-execute-plan`:
+
+- **Recipe C — Investigate-plan-execute.** `mma-investigate` → write the plan → `mma-execute-plan` → `mma-retry` on failed indices. Register the plan file as a context block before the execute-plan call so it isn't re-inlined into every worker's prompt; retry inherits the same configuration.
+- **Recipe D — Plan-execute-retry (entry point).** `mma-execute-plan` is the producer of the `batchId` that `mma-retry` consumes. When this batch returns mixed `done` / `failed`, the next call is `mma-retry` with failed indices, NOT a re-dispatch.
+
+Anti-pattern alert: **`full-batch-redispatch`** (AP4). When the batch returns mixed `done` / `failed`, do NOT re-run the whole task list — use `mma-retry` with the failed indices only. Re-running the whole list re-charges every successful task.
+
 ## Common pitfalls
 
 ❌ **Task descriptor doesn't match plan heading verbatim**

package/dist/skills/mma-investigate/SKILL.md

@@ -9,8 +9,10 @@ when_to_use: >-
   methodology skill, or from your own next-step planning — AND mmagent is
   running. Delegate the read/grep/synthesis to a worker so the main context
   stays on judgment. Codebase only — does not perform web research or
-  git-history queries.
-version: 3.6.5
+  git-history queries. OR you are about to read 3+ files / run any grep in main
+  context — that's the inline-labor-leakage anti-pattern (AP2); delegate to this
+  skill instead.
+version: 3.6.7
 ---
 
 # mma-investigate
@@ -121,6 +123,14 @@ Each task carries an `investigation` field on its per-task report:
 
 `workerStatus` is one of `done`, `done_with_concerns`, `needs_context`, `blocked`. When `done_with_concerns`, the per-task report carries `incompleteReason` (`turn_cap`, `cost_cap`, `timeout`, or `missing_sections`). When `needs_context`, the worker flagged a `[needs_context]` bullet under `## Unresolved` — re-dispatch with extra context (anchor paths, a context block, or a clarification turn).
 
+## Best practices
+
+This skill is one step in the larger flow described in `multi-model-agent` → "Best practices". Recipes that involve `mma-investigate`:
+
+- **Recipe C — Investigate-plan-execute.** `mma-investigate` → write the plan → `mma-execute-plan` → `mma-retry`. The investigation produces the synthesis you need to write the plan; the plan becomes a context block for execute-plan.
+
+Anti-pattern alert: **`inline-labor-leakage`** (AP2). If you find yourself reading 3+ files or running any grep in main context, that's the trigger to delegate here instead. Main-context tokens cost ~10× more than worker tokens, and you only need the synthesis, not the raw reads.
+
 ## Common pitfalls
 
 ❌ **Asking for a fix instead of an answer**

package/dist/skills/mma-retry/SKILL.md

@@ -10,7 +10,7 @@ when_to_use: >-
   you want to re-try the failed indices only. Prefer this over re-dispatching
   the whole batch or inline-retrying — it's idempotent and preserves the
   original batch's diagnostics.
-version: 3.6.5
+version: 3.6.7
 ---
 
 # mma-retry
@@ -88,6 +88,15 @@ BATCH_ID=$(echo "$BATCH" | jq -r '.batchId')   # NEW batchId — not the origina
 
 @include _shared/response-shape.md
 
+## Best practices
+
+This skill is one step in the larger flow described in `multi-model-agent` → "Best practices". Recipes that involve `mma-retry`:
+
+- **Recipe C — Investigate-plan-execute (last step).** After `mma-execute-plan` returns mixed results, retry the failed indices to close the loop.
+- **Recipe D — Plan-execute-retry.** Pass the **original `batchId`** as input, specify the failed indices, keep the same configuration. `mma-retry` produces a NEW `batchId` in its response — poll that one for terminal state. Any `contextBlockIds` from the original carry forward.
+
+Anti-pattern alert: **`full-batch-redispatch`** (AP4). Re-dispatching the entire batch re-charges every successful task. Always retry by index.
+
 ## Common pitfalls
 
 ❌ **Retrying after the batch expired**

package/dist/skills/mma-review/SKILL.md

@@ -10,7 +10,7 @@ when_to_use: >-
   AND mmagent is running. Delegate so each file reviews on its own worker; the
   main agent only decides what to merge. Review on SOURCE CODE — use mma-audit
   for prose specs / configs.
-version: 3.6.5
+version: 3.6.7
 ---
 
 # mma-review
@@ -75,6 +75,14 @@ BATCH_ID=$(echo "$BATCH" | jq -r '.batchId')
 
 @include _shared/response-shape.md
 
+## Best practices
+
+This skill is one step in the larger flow described in `multi-model-agent` → "Best practices". Recipes that involve `mma-review`:
+
+- **Recipe A (analog) — Review-iterate-clean.** `mma-review` → fix → `mma-review` again. Same shape as the audit recipe, applied to source code. Sequential rounds; register the file(s) via `mma-context-blocks` before round 1 and reuse the same ID across rounds.
+
+Anti-pattern alert: **`parallel-rounds-same-target`** (AP1). Three parallel reviews of the same source file re-flag the same issues. Run rounds sequentially with a fix between each.
+
 ## Common pitfalls
 
 ❌ **Reviewing a plan/spec markdown with `mma-review`**

package/dist/skills/mma-verify/SKILL.md

@@ -10,7 +10,7 @@ when_to_use: >-
   against implemented work BEFORE claiming success. Delegate so each checklist
   item gets independent evidence-gathering on a worker. Use this BEFORE saying
   "done" — never after.
-version: 3.6.5
+version: 3.6.7
 ---
 
 # mma-verify
@@ -76,6 +76,14 @@ BATCH_ID=$(echo "$BATCH" | jq -r '.batchId')
 
 @include _shared/response-shape.md
 
+## Best practices
+
+This skill is one step in the larger flow described in `multi-model-agent` → "Best practices". Recipes that involve `mma-verify`:
+
+- **Recipe B — Debug-fix-verify.** `mma-debug` → `mma-delegate` (fix) → `mma-verify`. Verify checks acceptance criteria against the implemented work. Reuse the context block registered for the debug call.
+
+Anti-pattern alert: **`parallel-rounds-same-target`** (AP1, verify analog). Two parallel `mma-verify` calls on the unchanged checklist re-flag the same gaps. Run verify → fix → re-verify sequentially instead.
+
 ## Common pitfalls
 
 ❌ **Vague checklist items**

package/dist/skills/multi-model-agent/SKILL.md

@@ -11,14 +11,14 @@ when_to_use: >-
   tasks — AND mmagent is running. Read this once, pick the matching mma-* skill,
   and delegate there. Applies equally whether the user invoked a superpowers
   methodology skill or asked directly.
-version: 3.6.5
+version: 3.6.7
 ---
 
 # multi-model-agent (router)
 
 ## Overview
 
-Local HTTP service that fans out tool-using work to sub-agents on different LLM providers (Claude, OpenAI-compatible, Codex). Workers run on cheap models; the main agent stays on judgment.
+Local HTTP service that fans out tool-using work to workers on different LLM providers (Claude, OpenAI-compatible, Codex). Workers run on cheap models; the main agent stays on judgment.
 
 **Core principle:** Pick the most specific `mma-*` skill that fits the task. Specificity reduces input — specialized skills know their route, schema, and defaults so you write less.
 
@@ -68,6 +68,65 @@ digraph picker {
 | `mma-context-blocks` | Register a reused doc once; reference by ID across N tasks |
 | `mma-clarifications` | Confirm or correct the service's proposed interpretation |
 
+## Best practices
+
+### The unifying principle
+
+The main session is for judgment, orchestration, and dialogue with the engineer. Everything else — read, grep, audit, review, debug, implement, verify — gets delegated. If you're about to do labor in main context, you've already taken the wrong turn.
+
+### Judgment vs labor — what NEVER delegates
+
+Labor handles work whose answer is findable from the inputs. Main session keeps work whose answer is **judgment** — there is no "right answer" a worker could discover:
+
+- **Brainstorming** — exploring the problem space with the engineer before a spec exists.
+- **Spec writing** — deciding what to build, what success looks like, what's out of scope.
+- **Plan writing** — turning a spec into ordered, testable steps with the right decomposition.
+- **Architecture and design decisions** — choosing the shape of the solution.
+- **Final approval / merge decisions** — what ships.
+- **Dialogue with the engineer** — clarifying intent, negotiating tradeoffs, answering "should we?".
+
+The test: *if a worker can produce the answer from the given inputs, delegate; if the answer requires deciding what the inputs should be, it's main-session work.* Recipes A–D all keep these judgment steps in main context (e.g., Recipe C explicitly: `mma-investigate` → **write the plan (main)** → `mma-execute-plan`).
+
+### C1 — Delegate by default, inline by exception
+
+If a task needs 3+ file reads or any grep, it goes to a worker. Inline `Read` is reserved for files already in context, single-file lookups, or 1-2 file reads with a known target.
+
+### C2 — Parallel for independence, sequential for iteration
+
+Independent fan-out (5 unrelated audits, 5 unrelated bugs) → parallel batch. Coupled rounds where round N's fix produces round N+1's input (audit → fix → re-audit, debug → fix → verify) → sequential.
+
+### C3 — Shared content lives in a context block, not in caller tokens
+
+Any artifact (spec, plan, prior-round findings, long error log) that crosses 2+ calls gets registered once via `mma-context-blocks` and referenced by ID.
+
+### Recipe A — Audit-iterate-clean
+
+`mma-audit` → read findings → fix (inline if 1-2 lines, else `mma-delegate`) → `mma-audit` again. Sequential rounds, NOT parallel re-audits. The fix produces new edges; round 2 catches what round 1 couldn't see. Register the doc as a context block before round 1; reuse the same ID across all rounds. The same shape applies to `mma-review` for source code (review → fix → re-review).
+
+### Recipe B — Debug-fix-verify
+
+`mma-debug` (read/reproduce/trace) → `mma-delegate` (apply the fix the hypothesis implies) → `mma-verify` (acceptance criteria checked independently). Three skills, strict order. Register the failing test output / reproduction log as a context block before the debug call; reuse it on verify.
+
+### Recipe C — Investigate-plan-execute
+
+`mma-investigate` (codebase Q&A) → write the plan (main-context judgment task) → `mma-execute-plan` (workers implement against named plan headings) → `mma-retry` on any failed indices. Register the plan file as a context block before execute-plan; the retry call inherits the same configuration including `contextBlockIds`.
+
+### Recipe D — Plan-execute-retry
+
+When `mma-execute-plan` returns mixed `done` / `done_with_concerns` / `failed`, the next step is `mma-retry` on the failed indices only — never a full-batch re-dispatch. Pass the **original `batchId`** as input, specify the failed task indices, keep the same configuration. (`mma-retry` produces a NEW `batchId` in its response — poll that one for terminal state, not the original.) Any `contextBlockIds` registered for the original batch carry forward into retry — no need to re-register.
+
+### Anti-patterns
+
+1. **`parallel-rounds-same-target`** — Caller fans out 3 parallel calls of the same skill on the same target — `mma-audit` on one document, `mma-review` on the same source file, or `mma-verify` of the same checklist. The reports overlap heavily; later rounds never see the fix from earlier rounds, so they re-flag the same issues. Corrective: sequential rounds with a fix between each (Recipe A for audit/review; for `mma-verify`, the analog is verify → fix → re-verify, never two verify calls on the unchanged checklist in parallel).
+
+2. **`inline-labor-leakage`** — Caller does 3+ `Read` calls, or any `grep`, in main context "just to understand the situation." Main tokens get burned on labor; the answer the caller actually needs is one paragraph of synthesis. Corrective: `mma-investigate` for codebase Q&A; if the goal is implementation, jump straight to `mma-delegate` with file paths and let the worker read.
+
+3. **`re-inlined-shared-content`** — Caller pastes the same spec / plan / error log into 5 task prompts in one batch (or across rounds). Token cost scales linearly with N. Corrective: `mma-context-blocks` register once, pass `contextBlockIds` to every task. C3 fires the moment the same content is referenced a second time.
+
+4. **`full-batch-redispatch`** — Caller re-runs `mma-execute-plan` with the entire task list when only 2 of 8 tasks failed. The 6 successful tasks get re-charged. Corrective: `mma-retry` with the failed indices. (The same anti-pattern applies to multi-task `mma-delegate` batches; `mma-retry` is the corrective there too.)
+
+5. **`clarification-as-info`** — Caller polls a batch, sees `proposedInterpretation` as a string, treats it as advisory, and waits for the batch to complete. The batch is paused — it will not complete until the caller responds via `mma-clarifications`. Corrective: a string `proposedInterpretation` is a hard gate, not an FYI. Either accept the proposal verbatim or correct it.
+
 ## Preflight: auto-start the daemon if it is not running
 
 ```bash

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhixuan92/multi-model-agent",
-  "version": "3.6.5",
+  "version": "3.6.7",
   "type": "module",
   "license": "MIT",
   "description": "Standalone HTTP server for multi-model-agent. Routes tool-invocation work to Claude, Codex, or OpenAI-compatible sub-agents with async-polling REST dispatch and installable skills for Claude Code, Gemini CLI, Codex CLI, and Cursor.",
@@ -52,7 +52,7 @@
   },
   "dependencies": {
     "@asteasolutions/zod-to-openapi": "^8.5.0",
-    "@zhixuan92/multi-model-agent-core": "^3.6.5",
+    "@zhixuan92/multi-model-agent-core": "^3.6.7",
     "gray-matter": "^4.0.3",
     "minimist": "^1.2.8",
     "proper-lockfile": "^4.1.2",