minima-cli 0.7.0__tar.gz → 0.7.2__tar.gz

minima_cli-0.7.2/.github/workflows/catalog-snapshot.yml

@@ -0,0 +1,100 @@
+name: Catalog — refresh vendored snapshot
+
+# Keeps the vendored cold-start model catalog fresh so it stops drifting by hand.
+#
+# WHAT/WHY: src/minima/catalog/data/capability_priors.json is the cold-start
+# fallback the server loads when the live cost feed (LiteLLM/OpenRouter) is
+# unreachable — see src/minima/catalog/store.py (load_snapshot_cards) and the
+# /v1/models router. It used to be hand-maintained and drifted stale (e.g.
+# missing the gpt-5 family). This job pulls the *live* served catalog from
+# api.minima.sh/v1/models — the source-of-truth that already merges curated
+# capability priors with live cost — normalizes it (via jq) into the EXACT
+# shape the loader reads, and opens a PR only when it actually changed.
+#
+# We deliberately DO NOT commit straight to main and DO NOT hand-edit the JSON:
+# a reviewer sees the diff, and the automation (not a human) keeps it current.
+on:
+  schedule:
+    - cron: "17 6 * * *" # daily (~every 24h); minute offset avoids the top-of-hour rush
+  workflow_dispatch: {}
+
+concurrency:
+  group: catalog-snapshot
+  cancel-in-progress: false
+
+# Least privilege: only what's needed to push a chore branch and open a PR.
+permissions:
+  contents: write
+  pull-requests: write
+
+env:
+  # Source-of-truth: the live served catalog. Override via repo/environment var
+  # CATALOG_SOURCE_URL if the prod host ever changes.
+  CATALOG_URL: ${{ vars.CATALOG_SOURCE_URL || 'https://api.minima.sh/v1/models' }}
+  SNAPSHOT_PATH: src/minima/catalog/data/capability_priors.json
+  BRANCH: chore/catalog-snapshot-auto
+
+jobs:
+  refresh:
+    name: Fetch live catalog → PR if changed
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v5
+
+      - name: Fetch + normalize live catalog into the vendored snapshot shape
+        run: |
+          set -euo pipefail
+          # /v1/models returns {models:[ModelCard...], catalog_version, stale}.
+          # ModelCard is a superset of the snapshot object, so we project it back
+          # to the exact fields load_snapshot_cards() reads and drop the runtime
+          # metadata (cost_source/cost_fetched_at/cost_stale/capability_source),
+          # which the loader always re-stamps as "fallback-snapshot".
+          curl -fsSL --retry 3 --retry-delay 5 --max-time 60 "$CATALOG_URL" -o live.json
+
+          count="$(jq '.models | length' live.json)"
+          if [ "$count" -lt 5 ]; then
+            echo "::error::live catalog returned only $count models (<5); refusing to overwrite snapshot"
+            exit 1
+          fi
+
+          version="fallback-snapshot-$(date -u +%Y-%m)"
+          note="Cold-start fallback only. Auto-refreshed by .github/workflows/catalog-snapshot.yml from the live /v1/models catalog — do not hand-edit. Live cost is overlaid from LiteLLM/OpenRouter at runtime; capability_by_task_type are normalized [0,1] heuristic priors, corrected by accumulated memory. Prices are approximate USD per million tokens."
+
+          jq \
+             --arg version "$version" \
+             --arg note "$note" '{
+               version: $version,
+               note: $note,
+               models: (.models | sort_by(.model_id) | map({
+                 model_id, provider, display_name,
+                 input_cost_per_mtok, output_cost_per_mtok, cache_read_cost_per_mtok,
+                 supports_prompt_caching, context_window, max_output_tokens,
+                 capability_priors, capability_by_task_type
+               }))
+             }' live.json > "$SNAPSHOT_PATH.tmp"
+          mv "$SNAPSHOT_PATH.tmp" "$SNAPSHOT_PATH"
+          rm -f live.json
+          echo "Normalized $count models into $SNAPSHOT_PATH"
+
+      - name: Commit + open PR only if the snapshot changed
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          set -euo pipefail
+          if git diff --quiet -- "$SNAPSHOT_PATH"; then
+            echo "Snapshot already up to date; nothing to do."
+            exit 0
+          fi
+
+          git config user.name "github-actions[bot]"
+          git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
+          git checkout -B "$BRANCH"
+          git add "$SNAPSHOT_PATH"
+          git commit -m "chore(catalog): refresh vendored model snapshot from live /v1/models"
+          git push -u origin "$BRANCH" --force-with-lease
+
+          gh pr create --base main --head "$BRANCH" \
+            --title "chore(catalog): refresh vendored model snapshot" \
+            --body "Automated refresh of \`$SNAPSHOT_PATH\` from the live catalog at \`$CATALOG_URL\` (normalized to the loader's shape). Opened by \`.github/workflows/catalog-snapshot.yml\`. Review the diff — this is the cold-start fallback the server serves when the live cost feed is unreachable." \
+            || echo "PR already open for $BRANCH; pushed update."

minima_cli-0.7.2/.github/workflows/ci.yml

@@ -0,0 +1,69 @@
+name: CI — PR checks
+
+# Gate on every PR to main (and on push to main) with the exact local test
+# conventions: server (ruff + offline pytest) and TUI (bun test + tsc). Two
+# independent jobs so a red on one surfaces without masking the other. No
+# deploy, no secrets — the suites are offline (`-m "not live and not eval"`).
+# mypy runs after ruff/pytest: src/minima is now type-clean, so it gates too.
+on:
+  pull_request:
+    branches: [main]
+  push:
+    branches: [main]
+
+concurrency:
+  group: ci-${{ github.ref }}
+  cancel-in-progress: true
+
+permissions:
+  contents: read
+
+env:
+  BUN_VERSION: "1.3.14"
+
+jobs:
+  server:
+    name: Server — ruff + pytest + mypy
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v5
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v6
+
+      - name: Sync deps (dev extra)
+        run: uv sync --extra dev
+
+      - name: Ruff
+        run: uv run ruff check src client_sdk tests
+
+      - name: Pytest (offline)
+        run: uv run pytest -m "not live and not eval" -q
+
+      - name: Mypy
+        run: uv run mypy src/minima
+
+  tui:
+    name: TUI — bun test + tsc
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: packages/tui
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v5
+
+      - name: Set up Bun
+        uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: ${{ env.BUN_VERSION }}
+
+      - name: Install deps
+        run: bun install --frozen-lockfile
+
+      - name: Test
+        run: bun test
+
+      - name: Typecheck
+        run: bun run check

{minima_cli-0.7.0 → minima_cli-0.7.2}/.gitignore

@@ -13,6 +13,10 @@ build/
 .minima_state/
 .seed_progress.json
 
+# Local experimental / throwaway files
+scratch/
+playground/
+
 
 # Astro docs site
 docs-site/node_modules/

{minima_cli-0.7.0 → minima_cli-0.7.2}/CHANGELOG.md

@@ -4,6 +4,69 @@ All notable changes to Minima are documented here. The format follows
 [Keep a Changelog](https://keepachangelog.com/), and the project aims to follow
 [Semantic Versioning](https://semver.org/).
 
+## [0.7.2] - 2026-07-06
+
+### Added (TUI)
+- **Fullscreen renderer (new default)** — alternate screen buffer with the prompt glued
+  to the bottom row, height-accurate transcript windowing, and in-app history scrolling
+  (mouse wheel / trackpad on by default; PgUp/PgDn always work). Opt out with
+  `--no-fullscreen` or `MINIMA_TUI_INLINE=1` for the classic inline renderer with native
+  terminal scrollback.
+- **Live current-action line** — while a tool runs, the footer shows what the agent is
+  doing right now (e.g. `⚙ bash: git diff --stat`), with `(+N more)` for parallel tools.
+- **New tools**: `question` (ask the user mid-run, never permission-gated),
+  `apply_patch` (multi-file add/update/delete/move), and Exa-backed `web_search` +
+  `web_fetch` (require `EXA_API_KEY`).
+- `--thinking LEVEL` is now actually applied (was parsed but ignored).
+- Busy indicator with rotating tips; thinking states renamed to `reasoning`/`running`.
+
+### Fixed (TUI)
+- **Esc / Ctrl+C abort a running turn** (was dead code behind the busy guard); a second
+  Ctrl+C within 2.5s force-quits even if a provider stream cannot be cancelled.
+- Plan mode (read-only) blocks `apply_patch` alongside write/edit/bash.
+- Live streaming region can never outgrow the viewport: over-budget final lines are
+  hard-sliced (fixes the fullscreen garble class and inline scrollback wipes).
+- `/fork` and `/clone` no longer claim fake success — they say they're not implemented.
+- glob/grep are permission-scoped as directory READS (`read from <dir>`) instead of
+  generic `run glob` prompts.
+
+### Changed (TUI)
+- **Permission denials are reframed for the model** ("the user declined … do not retry
+  the call and do not attempt the same action through other tools") — stops the
+  sandbox-spiral where models retry or work around a deliberate user decline.
+- Memory-recall block is annotated reference-only (do NOT run tools from recall).
+
+## [0.7.1] - 2026-07-05
+
+### Changed (API behavior — note for integrators)
+- **`max_cost_per_call` is now a true hard filter.** When no model fits the budget,
+  `POST /v1/recommend` returns **422** (`"no model within max_cost_per_call budget"`)
+  instead of 200 with the cheapest over-budget model plus a `no_model_within_cost_budget`
+  warning. This matches the documented "hard filter" contract and the existing
+  no-candidates behavior. Callers who want "cheapest possible regardless of ceiling"
+  should use the cost-quality slider, not `max_cost_per_call`.
+- **Auth rejects malformed bearer tokens.** A bearer token that is not in the Mubit key
+  format (`mbt_…`) now returns **401** before any work, instead of being accepted and
+  served from priors. A missing bearer with a server-configured `MUBIT_API_KEY` fallback
+  is unaffected.
+
+### Fixed
+- **Cold-start catalog prices were stale.** The vendored fallback snapshot
+  (`capability_priors.json`) is refreshed from the live catalog (e.g. `claude-opus-4-8`
+  `15/75` → `5/25`), and a scheduled workflow now keeps it current so it stops drifting
+  by hand. (The auto-refresh updates prices for the curated model list; it does not add
+  new models — expanded provider coverage such as the gpt-5 family remains a separate
+  curation.)
+- **Server version string can no longer drift.** `minima.__version__` (reported by
+  `/v1/health` and `/v1/capabilities`) now derives from installed package metadata instead
+  of a hardcoded constant that had silently lagged across releases.
+- **Feedback reconciliation types the quality value honestly** as `float | None` — unjudged
+  rows keep `NULL`, no fabricated default (preserves the M-J2 fix).
+
+### Internal
+- **PR CI added** — every PR now runs server (`ruff` + `pytest` + `mypy`) and TUI
+  (`bun test` + `tsc`) checks; the recommender is mypy-clean.
+
 ## [0.7.0] - 2026-07-05
 
 ### Added

{minima_cli-0.7.0 → minima_cli-0.7.2}/Makefile

@@ -1,4 +1,4 @@
-.PHONY: install run test lint fmt live eval seed refresh-catalog tui-install tui-test tui-check tui-build tui tui-dev
+.PHONY: install run test lint fmt live eval seed refresh-catalog tui-install tui-test tui-check tui-build tui tui-dev tui-shot
 
 install:
 	uv sync --extra dev   # dev pulls server + reasoner extras for the full test suite
@@ -30,6 +30,9 @@ seed:
 
 TUI := packages/tui
 TUI_BIN := $(TUI)/dist/minima
+# Default PTY-capture spec: idle interactive UI at 100x30, run from the repo root so .env loads.
+# Emits a PNG to the gitignored playground/ so the rendered UI can be inspected as an image.
+SPEC ?= {"cmd":["bun","run","$(TUI)/src/cli/main.ts","--offline"],"cwd":"$(CURDIR)","cols":100,"rows":30,"duration":6,"png":"$(CURDIR)/playground/tui-shot.png"}
 
 tui-install:
 	cd $(TUI) && bun install
@@ -54,3 +57,11 @@ tui:
 # Run from source via Bun (no compile step) — fastest dev loop.
 tui-dev:
 	cd $(TUI) && bun run src/cli/main.ts $(ARGS)
+
+# Capture a text "screenshot" of the TUI in a real PTY (pyte emulator). No committed venv — uv pulls
+# pyte on demand. Override SPEC to size the terminal / send keystrokes; see the script's docstring:
+#   make tui-shot
+#   make tui-shot SPEC='{"cmd":["bun","run","packages/tui/src/cli/main.ts","--offline","--model","claude-haiku-4-5","--provider","anthropic"],"cwd":"'"$$PWD"'","cols":80,"rows":24,"duration":8,"steps":[{"after":2,"send":"hi<CR>"}]}'
+tui-shot:
+	@mkdir -p $(CURDIR)/playground
+	uv run --with pyte --with pillow python $(TUI)/scripts/pty_capture.py '$(SPEC)'

{minima_cli-0.7.0 → minima_cli-0.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: minima-cli
-Version: 0.7.0
+Version: 0.7.2
 Summary: Minima CLI: cost-aware LLM model routing — recommend cheaper models, backed by Mubit memory.
 Project-URL: Homepage, https://docs.minima.sh
 Project-URL: Documentation, https://docs.minima.sh

minima_cli-0.7.2/docs/feature-gap-analysis.md

@@ -0,0 +1,190 @@
+# Feature Gap Analysis: minima vs. Claude Code, Codex CLI & OpenCode
+
+**Date:** 2026-07-02
+**Scope:** The minima **coding agent** (`src/minima_harness/`, the `minima` CLI/TUI, v0.5.0 "Beta"). The routing service in `src/minima/` is minima's wedge, not the comparison surface.
+**Comparators:** Claude Code (Anthropic), Codex CLI (OpenAI), OpenCode (open source).
+**Goal:** Rank the features these three have that minima lacks, by **popularity/usability**, **time to build**, and **compatibility with minima's architecture**.
+
+---
+
+## How to read this
+
+- **Popularity / Usability (1–5):** How strongly users expect the feature in 2026. 5 = table-stakes.
+- **Build effort:** Engineer-days for a first solid version, with a T‑shirt size. *Lower is better.*
+- **Compatibility (1–5):** How cleanly it slots into minima's existing architecture (tools system, routing loop, session store, extensions). 5 = drop-in / synergistic.
+- **Priority rank:** My recommended build order, balancing all three. High value + low effort + high fit floats to the top; a couple of high-effort items still rank high because they are table-stakes.
+
+The ranking is a recommendation, not a formula output — the numeric columns are there so you can re-weight if your priorities differ (e.g., if enterprise security matters more, sandboxing jumps up).
+
+---
+
+## Executive summary
+
+Minima's coding agent is a competent port of the PI agent toolkit with a **genuinely differentiated core**: cost-aware model routing across a large multi-provider pool, memory-backed learning from realized outcomes, and per-turn/per-goal cost tracking. Nothing in the comparators matches that wedge.
+
+But on the *table-stakes agent surface*, it trails all three comparators in a few specific, high-visibility places. The biggest gaps, in order: **MCP support** (all three have it; minima has none), **sub-agents** (all three; minima is single-agent), **LSP feedback** (OpenCode's marquee feature; minima scaffolded then deleted it), **web search/fetch** (Claude Code + Codex; minima has none), and **plan mode** (all three; minima has a `# TODO` where it should be).
+
+The good news: several of these are cheap because minima already has the substrate — the tools system, the routing/judge loop, image plumbing, and `/compact` all exist. Five of the top seven items are days-scale, not weeks-scale.
+
+### Top-15 ranked table
+
+| # | Feature (minima lacks) | Who has it | Popularity/Usability | Build effort | Compatibility | Notes / minima synergy |
+|---|---|---|:--:|---|:--:|---|
+| 1 | **MCP client support** | CC, Codex, OC | 5 | ~5–8d (**M**) | 5 | Table-stakes ecosystem. MCP tools map onto the existing tool interface; routing treats them as more tools. |
+| 2 | **Web search / fetch tool** | CC, Codex | 5 | ~2–3d (**S**) | 5 | Two new builtin tools over a search API. Highest ROI after image input. |
+| 3 | **Expose image/vision input** | Codex | 4 | ~1–2d (**XS**) | 5 | Already plumbed end-to-end (`ai/types.py:ImageContent`, all 3 providers); only the TUI attach path is missing. Fastest win in the doc. |
+| 4 | **Plan mode (read-only)** | CC, Codex, OC | 5 | ~3–4d (**S**) | 5 | `ROUTE_MODES=("auto","confirm")` + tool gating exist; the plan/act split is already a documented **"Phase‑3"** item (`app.py:98`) — design intent exists, de-risking the build. |
+| 5 | **Automatic context compaction** | CC | 4 | ~2–3d (**S**) | 5 | Notice site (`app.py:945`) + reusable `summarize()` both exist; wire an auto-trigger there. |
+| 6 | **`/review` code-review command** | Codex | 4 | ~2–3d (**S**) | 5 | Diff vs. base/commit → review prompt routed to a strong model. Pure reuse of git(bash)+routing. |
+| 7 | **Sub-agents / multi-agent** | CC, Codex, OC | 5 | ~8–15d (**L**) | 4 | Biggest *differentiation* opportunity: route **each subagent independently to the cheapest capable model**. No competitor does cost-routed fan-out. |
+| 8 | **LSP integration (re-add)** | OC | 4 | ~8–12d (**L**) | 4 | Feeds compiler diagnostics back into the loop → sharper quality/judge signal → strengthens minima's feedback thesis. Was scaffolded (`lsp/` now stale `.pyc` only). |
+| 9 | **Filesystem checkpoints / rewind** | CC, OC (undo), Codex (git) | 5 | ~6–10d (**M/L**) | 4 | Session tree branches *conversations*; extend to snapshot *files* per turn + restore. |
+| 10 | **Dedicated git integration** | CC, Codex, OC | 4 | ~3–5d (**S/M**) | 4 | Status/diff/branch awareness in context + optional auto-commit. Today git is bash-only. |
+| 11 | **Best-of-N / parallel attempts** | Codex (`--attempts`) | 3 | ~4–6d (**M**) | 5 | Natural fit: judge + routing already exist. Run N candidates across models, judge, pick. A routing differentiator. |
+| 12 | **Sandboxing (OS-level)** | CC, Codex | 4 | ~10–15d (**L/XL**) | 3 | bash runs with full user perms today. Platform-specific (seatbelt/landlock/container). Enterprise value. |
+| 13 | **Session sharing (`/share`)** | OC | 3 | ~5–8d (**M**) + infra | 3 | Needs a hosting backend — Mubit could host it (synergy), otherwise heavy. |
+| 14 | **IDE integrations (VS Code/JetBrains)** | CC, Codex, OC | 5 | ~20–40d (**XL**) | 2 | High demand but a whole new product surface; needs an exposed agent server protocol. |
+| 15 | **Desktop / web app** | CC, OC | 4 | ~25–40d (**XL**) | 2 | Long-term; large surface, low reuse of the TUI. |
+
+**Micro-wins (do opportunistically, each < 1 day):** fuzzy `@`-file picker (Codex has autocomplete; minima's `@path` only inlines a known path), external prompt editor via `$EDITOR`/Ctrl+G (Codex), shell completions (`codex completion …`), `/copy` of last output (minima has `/copy`+`/export` already — mostly covered).
+
+---
+
+## Recommended roadmap (sequenced)
+
+**Sprint 1 — Quick wins (≈2 weeks, all days-scale, high visibility):**
+`#3 image input` → `#2 web search/fetch` → `#4 plan mode` → `#5 auto-compaction` → `#6 /review`. These close five obvious "why doesn't it do X" gaps for ~10–16 engineer-days total and touch only the tools/TUI/route-mode layers.
+
+**Sprint 2 — Table-stakes core (≈2 weeks):**
+`#1 MCP client` (the single most important gap; unlocks the whole external-tool ecosystem) + `#10 git integration`.
+
+**Sprint 3 — Strategic differentiators (≈4–6 weeks):**
+`#7 cost-routed sub-agents` and `#8 LSP re-add`. These are the two places where minima's wedge (routing + outcome feedback) turns a copied feature into a *better* feature. Add `#11 best-of-N` and `#9 checkpoints` as they fit.
+
+**Backlog / heavy bets:** `#12 sandboxing`, `#13 sharing`, `#14 IDE`, `#15 desktop/web`.
+
+---
+
+## Detail & build notes
+
+### Tier 1 — Quick wins
+
+- **Image/vision input (#3).** The hard part is done: `ImageContent(data: base64, mime_type)` is fully defined (`ai/types.py:104`) and all three providers (`anthropic-messages`, `google-generative-ai`, `openai-completions`) already serialize images. Missing: a user path to attach one — `editor.py:21` only inline-expands *text* `@path`. Add a `-i/--image` CLI flag and a paste/`@image.png` route that builds an `ImageContent` and injects it. ~1–2 days.
+- **Web search / fetch (#2).** Append two `AgentTool`s to `default_toolset()` (`tools/builtin.py:13`) backed by a search API (Brave/Tavily/Exa) or provider-native grounding. Minima already routes to web-grounded models (Perplexity Sonar) but has no tool. ~2–3 days.
+- **Plan mode (#4).** `ROUTE_MODES = ("auto","confirm")` at `app.py:99`; the plan/act split is explicitly deferred to "Phase‑3" in the comment at `app.py:98`, and tool gating (`-nt`, `--exclude-tools`) already exists. Add a read-only mode that restricts to `read/grep/find/ls`, produces a plan, and gates execution behind approval. ~3–4 days. (Team roadmap intent already documented — lower design risk.)
+- **Auto-compaction (#5).** The trigger site already exists: `app.py:945` shows `"context near limit — /compact to free space"` today, and `summarize(messages, model, *, instructions="")` (`tui/compaction.py:8`) is a clean reusable async fn. Auto-compaction = call `summarize()` at that notice point instead of just warning. ~2–3 days (revised down from 4 — the hook and summarizer both exist).
+- **`/review` (#6).** A slash command that diffs against a base branch / uncommitted changes (git via bash), builds a review prompt, and routes it to a strong model. Pure reuse. ~2–3 days.
+
+### Tier 2 — Table-stakes core
+
+- **MCP client (#1).** The highest-impact gap: all three comparators support MCP; minima has neither client nor server (grep-confirmed absent). Implement a stdio + streamable-HTTP client, register discovered tools into the existing tool registry, and add config. Because minima's tool interface is already pluggable (extensions register tools today), MCP tools slot in cleanly and are automatically eligible for routing/permissions. ~5–8 days. (A `codex mcp-server`-style server that exposes minima *as* an MCP tool is a separate, later item.)
+- **Git integration (#10).** Surface `git status`/diff/branch into context, be gitignore-aware, optionally offer auto-commit with generated messages. ~3–5 days.
+
+### Tier 3 — Strategic differentiators (lean into the wedge)
+
+- **Cost-routed sub-agents (#7).** All three comparators spawn subagents; **none route each subagent to the cheapest capable model.** Minima can: a spawn tool + isolated context + result synthesis, with every child going through the recommend→judge→feedback loop. This makes "fan out 5 agents" measurably cheaper and is a story no competitor can tell. The loop is already anyio-parallel, so concurrency isn't from scratch. ~8–15 days.
+- **LSP re-add (#8).** OpenCode's headline feature: feed compiler diagnostics back after each edit so the model self-corrects. This is *directly aligned* with minima's outcome-feedback thesis — diagnostics become a quality signal for the judge and for routing feedback. Source was scaffolded and deleted (`lsp/` and `tests/harness/lsp/` hold only stale `.pyc`), so prior design exists to mine. ~8–12 days.
+- **Best-of-N routing (#11).** Codex Cloud has `--attempts` (1–4). Minima already has a judge and multi-model routing — run N candidates across models, judge, select the winner, and log outcomes. A routing-native version of a known feature. ~4–6 days.
+- **Checkpoints / rewind (#9).** Users expect an undo net (Claude Code rewind, OpenCode undo/redo). Snapshot touched files per turn and restore on request; integrate with the existing session tree so a rewind can branch conversation *and* files together. ~6–10 days.
+
+### Tier 4 — Heavy / long-term
+
+- **Sandboxing (#12):** OS-level isolation for `bash` (seatbelt on macOS, landlock/seccomp on Linux, or containers). Real enterprise value but platform-specific and invasive. ~10–15 days.
+- **Session sharing (#13):** `/share` link. Needs a hosting backend — a natural thing for Mubit to host, otherwise expensive. ~5–8 days + infra.
+- **IDE integrations (#14) / Desktop-web app (#15):** New product surfaces requiring an exposed agent server protocol; high demand, weeks-to-months of work, low reuse of the current TUI.
+
+---
+
+## What minima already matches (not gaps)
+
+So this doesn't read as "behind on everything" — minima is at parity or ahead here:
+
+- **Slash commands** (~37), **skills** (Agent Skills standard + Mubit skills), **prompt templates** as `/commands`, **custom commands** — parity.
+- **Hooks/extensibility:** Python extensions register tools/commands/event hooks (`text`/`tool_start`/`tool_end`/`turn`/`finish`) + a git-based **package manager** (`minima install <git-url>`) — comparable to plugins.
+- **Permissions/approval modes:** PermissionRequest modal, always-allow, `/yolo`, `--dangerously-skip-permissions`, `/edits` forced diff review — parity (minus sandboxing).
+- **Headless/scripting:** `--print` and `--mode json` event stream — matches `codex exec` / `claude -p`.
+- **Sessions:** append-only JSONL session **tree** with continue/resume/fork/clone/branch + goals that survive resume — arguably *ahead* of the comparators on branching.
+- **Themes, keybinds, mouse select+copy, `/export` to Markdown, diff preview, `/stats`+`/cost` analytics** — parity or better on cost analytics.
+- **Multi-provider:** Anthropic, Google, and an OpenAI-compatible path covering OpenAI/OpenRouter/Groq/Together/Fireworks/DeepInfra/Cerebras/DeepSeek/Mistral/xAI/Perplexity, etc. — **plus first-class local-runtime specs for Ollama, LM Studio, vLLM, llama.cpp, and LocalAI** (`ai/provider_catalog.py:110–124`, no API key required, e.g. Ollama at `localhost:11434/v1`). This is *ahead* of most comparators on local-runtime breadth. *(Corrected in iteration 5 — the initial inventory wrongly reported no local provider.)*
+
+## Minima's unique wedge (protect and lean into)
+
+No comparator has: **cost-aware routing across a large candidate pool**, **memory-backed learning from realized outcomes** (`/recall`, `/optimize`, learned lessons), and **cost/budget tracking** (est-vs-actual-vs-baseline savings %, budgeted `/ledger` goals). The strategic read: build the table-stakes gaps to remove reasons *not* to use minima, but make sub-agents, best-of-N, and LSP feedback **routing-native** so the copied features are cheaper/smarter than the originals.
+
+---
+
+## Validation notes (iteration 2 — 2026-07-02)
+
+The Tier‑1 estimates were re-checked against source (not just inferred from the inventory). All held; a couple were revised down because the reuse points exist:
+
+| Claim | Verified against | Result |
+|---|---|---|
+| Image plumbed but not exposed | `ai/types.py:104` (`ImageContent(data:base64, mime_type)`), `editor.py:21` (text-only `@path`) | ✅ Confirmed — only the TUI attach path is missing. |
+| Plan mode absent, scaffold exists | `app.py:98–99` (`ROUTE_MODES=("auto","confirm")`, "Phase‑3 plan/act split" comment) | ✅ Confirmed — and it's already on the team roadmap. |
+| Auto-compaction absent | `app.py:945` (warn-only notice), `_compact` at `app.py:1226`, reusable `summarize()` at `compaction.py:8` | ✅ Confirmed — **estimate revised 2–4d → 2–3d** (hook + summarizer exist). |
+| Web search/fetch absent | grep across `src/minima_harness/` (empty); `default_toolset()` at `tools/builtin.py:13` is the clean insertion point | ✅ Confirmed absent, insertion point trivial. |
+| MCP absent | grep across `src/minima_harness/` (empty) | ✅ Confirmed absent (client and server). |
+
+### Tier‑2/3 validation (iteration 3 — 2026-07-02)
+
+Source-checked the expensive roadmap-driving items. All estimates held; compatibility claims confirmed, with sharpened risk notes:
+
+| Item | Verified against | Result / refinement |
+|---|---|---|
+| MCP client (#1, ~5–8d, fit 5) | `AgentTool` dataclass (`agent/tools.py:42`: `name`/`description`/`parameters: type[BaseModel]`/async `execute`); extensions already register `AgentTool`s dynamically (`extensions.py:30`) | ✅ Fit confirmed. The **one real risk** is bridging MCP's JSON-Schema tool params → a pydantic model (`pydantic.create_model` or a passthrough model). Everything else is wiring. |
+| Cost-routed sub-agents (#7, ~8–15d, fit 4) | `agent_loop(...)` is a plain async fn over explicit `AgentState`/`AgentLoopConfig` (`loop.py:48`); tool exec already parallel via `anyio.create_task_group()` (`loop.py:245`) | ✅ Nesting a child loop is clean (no global refactor); concurrency primitives exist. The cost-routing-per-child synergy is real — each child re-enters the same runtime. |
+| LSP re-add (#8, ~8–12d, fit 4) | Only `.pyc` survives (`lsp/__pycache__/` client+manager+protocol + compiled tests); no `.py` source | ✅ Estimate holds. Module split is a **design hint only** — py3.14 decompilers are immature, so don't count on recovering the deleted code. |
+| Checkpoints/rewind (#9, ~6–10d, fit 4) | `SessionStore` is a conversation DAG (`store.py`: `append`/`set_tip`/`fork_to`/`path_to`), not file state | ✅ Estimate holds; **refinement:** the DAG is a clean anchor for rewind, but the per-turn **file-snapshot layer is net-new** (fit is really 3–4). |
+| Git integration (#10, ~3–5d, fit 4) | No dedicated git code (bash-only); context assembled in `tui/context.py` | ✅ Pure context injection (shell out to git, summarize into context) + optional auto-commit. Low risk. |
+
+Tier‑4 items (sandboxing, sharing, IDE, desktop/web) remain first-pass — deliberately, as they're backlog.
+
+---
+
+## Changelog refresh (iteration 4 — 2026-07-02)
+
+Swept the **June–July 2026** changelogs to keep the gap list current. Net: the existing top gaps got *reinforced* (the bar rose), a few new candidates appeared, and — notably — a competitor started copying minima's wedge.
+
+**Existing gaps reinforced (the bar moved):**
+- **Sub-agents (#7):** Claude Code now ships **nested sub-agents (3-level depth)**, `fallbackModel` chains, and background-subagent permission prompts routed to the main session. The expectation moved from "has subagents" to "has *nested, resilient* subagents" — which makes minima's cost-routed-fan-out angle more valuable, not less.
+- **MCP (#1):** now table-stakes-plus — Claude `claude mcp login/logout`, Codex smarter MCP tool-search, OpenCode MCP OAuth + refresh tokens + resource autocomplete. Minima is still at zero; this remains the #1 gap.
+- **Checkpoints/rewind (#9):** Claude `/rewind` can now restore from *before* `/clear` was run.
+- **Web search (#2):** Codex added an **indexed mode** (live search but restricted to server-approved URLs) — a safer default worth copying when minima builds this.
+
+**New candidate gaps (June 2026):**
+
+| Candidate | Who shipped it | Pop. | Effort | Fit | Where it slots |
+|---|---|:--:|---|:--:|---|
+| Test-runner auto-detection + run | OpenCode (cargo/uv/bun/dotnet) | 3 | ~2–3d (**S**) | 5 | Confirmed absent in minima (no in-agent test integration; bash-only). A tool/context add that routes a "run tests" action. Tier-1-sized quick win. |
+| Mobile / remote control | Codex Remote GA (QR pairing), CC remote | 4 | ~20–40d (**XL**) | 2 | New surface (server + device pairing). Backlog, alongside IDE. |
+| Org/admin policy controls (default model, governance) | Claude Code org defaults | 2–3 | ~5–8d (**M**) | 3 | Enterprise/team governance. Backlog. |
+
+*Dropped candidate (iteration 5):* "first-class Ollama support" — **minima already has it** (see parity list below). OpenCode's only edge here is *optimized* local streaming (Ollama streaming v2, ~−40% first-token latency) — a minor perf item, not a feature gap.
+
+**Already at parity with newly-shipped features (no action needed):**
+- OpenCode just added a **yolo mode** to auto-approve permissions — minima has `/yolo` + `--dangerously-skip-permissions` already.
+- OpenCode's `--session` transcript pinning — minima has `--session` **plus** a full session tree.
+- **Local models** — OpenCode/Ollama focus notwithstanding, minima ships first-class specs for Ollama, LM Studio, vLLM, llama.cpp, and LocalAI (`ai/provider_catalog.py:110–124`). Minima is ahead here on breadth; the only competitor edge is streaming latency tuning.
+- **Codex just shipped "rollout token budgets" that abort a turn when exhausted** — a step *toward* minima's existing cost/budget wedge (`/ledger` budgeted goals, per-turn est-vs-actual-vs-baseline savings). Signal: the market is moving toward minima's differentiator. **Suggested move:** add a hard budget-abort to `/ledger` to stay a step ahead of where Codex just landed.
+
+---
+
+## Sources
+
+- Claude Code — [25 Features Guide 2026 (MarkTechPost)](https://www.marktechpost.com/2026/06/14/claude-code-guide-2026-25-features-with-examples-demo/), [Subagents docs](https://code.claude.com/docs/en/sub-agents), [Hooks/Subagents/Skills guide](https://ofox.ai/blog/claude-code-hooks-subagents-skills-complete-guide-2026/)
+- Codex CLI — [Features](https://developers.openai.com/codex/cli/features), [CLI docs](https://developers.openai.com/codex/cli), [Changelog](https://developers.openai.com/codex/changelog), [Codex as MCP server](https://codex.danielvaughan.com/2026/05/12/codex-cli-agents-sdk-mcp-server-multi-agent-workflows/)
+- OpenCode — [Docs / intro](https://opencode.ai/docs/), [GitHub](https://github.com/opencode-ai/opencode), [Developer guide 2026](https://www.developersdigest.tech/blog/opencode-developer-guide-2026)
+- June–July 2026 changelogs — [Codex changelog](https://developers.openai.com/codex/changelog), [Codex June 2026 recap](https://www.developersdigest.tech/blog/codex-changelog-june-2026), [Claude Code what's new](https://code.claude.com/docs/en/whats-new), [Claude Code June 2026 features](https://www.sitepoint.com/claude-code-june-2026-10-new-features-devs-need-to-know/), [OpenCode changelog](https://opencode.ai/changelog)
+- minima — codebase inventory (`src/minima_harness/`), `docs/harness.md`, `README.md`
+
+*Build estimates assume one engineer familiar with the codebase. Tier‑1 through Tier‑3 estimates have been source-validated (see Validation notes); Tier‑4 remains first-pass by design.*
+
+---
+
+## Revision history
+
+- **Iteration 1** — Initial report: minima feature inventory + competitor research → ranked 15-item gap table + 3-sprint roadmap.
+- **Iteration 2** — Source-validated Tier‑1 estimates; revised auto-compaction down (2–4d → 2–3d).
+- **Iteration 3** — Source-validated Tier‑2/3 estimates (MCP JSON-Schema bridge risk, clean sub-agent nesting, LSP `.pyc`-only remnants, net-new checkpoint file layer).
+- **Iteration 4** — June–July 2026 changelog refresh: reinforced gaps, new candidates, and the signal that Codex is converging on minima's cost-budget wedge.
+- **Iteration 5** — Validated new candidates; **corrected a factual error** — minima already ships first-class local-runtime providers (Ollama/LM Studio/vLLM/llama.cpp/LocalAI); confirmed test-runner detection is a genuine gap. Report considered complete.

{minima_cli-0.7.0 → minima_cli-0.7.2}/packages/tui/README.md

@@ -44,6 +44,24 @@ Tests are fully hermetic: the client injects a mock `fetch`, the faux provider s
 LLM replies, and the Minima integration runs the full loop against an in-process mock
 service — no network, no keys.
 
+### Screenshot the TUI
+
+To inspect the layout as a "screenshot", drive the TUI in a real PTY with `scripts/pty_capture.py`
+(pyte emulator; no committed venv — `uv` pulls pyte/pillow on demand):
+
+```bash
+# from the repo root (so .env / .env.harness load):
+make tui-shot                                  # idle UI at 100x30 -> playground/tui-shot.png
+make tui-shot SPEC='{"cmd":["bun","run","packages/tui/src/cli/main.ts","--offline","--model","claude-haiku-4-5","--provider","anthropic"],"cwd":"'"$PWD"'","cols":80,"rows":24,"duration":8,"png":"'"$PWD"'/playground/shot.png","steps":[{"after":4,"send":"hi"},{"after":6,"send":"<CR>"}]}'
+```
+
+It prints the visible grid plus the **scrollback** (lines that scrolled off the top), and — when the
+spec has a `"png"` key — rasterizes the visible grid (colors/bold, Menlo font) to a **PNG image** you
+can open. Verifies "prompt at the bottom / clean render / scroll"; true wheel/trackpad scrolling is a
+real-terminal, human check. Tips: give Ink ~4s to warm up and send the prompt text and `<CR>` as
+separate `steps`. See the script's docstring for the full JSON spec and send-tokens
+(`<CR> <UP> <PGUP> <CTRLC> …`).
+
 ## Use
 
 ```bash

{minima_cli-0.7.0 → minima_cli-0.7.2}/packages/tui/bun.lock

@@ -10,6 +10,7 @@
         "@mubit-ai/sdk": "^0.10.0",
         "ink": "^5.0.0",
         "react": "^18.3.0",
+        "string-width": "^7.2.0",
       },
       "devDependencies": {
         "@biomejs/biome": "^1.9.0",

{minima_cli-0.7.0 → minima_cli-0.7.2}/packages/tui/package.json

@@ -1,6 +1,6 @@
 {
   "name": "minima-tui",
-  "version": "0.7.0",
+  "version": "0.7.2",
   "description": "Minima harness + TUI — the `minima` CLI (TypeScript/Ink; successor to the removed Python harness). Talks to the Python FastAPI recommender service over the /v1/* contract.",
   "type": "module",
   "license": "FSL-1.1-Apache-2.0",
@@ -32,7 +32,8 @@
     "@google/genai": "^0.3.0",
     "@mubit-ai/sdk": "^0.10.0",
     "ink": "^5.0.0",
-    "react": "^18.3.0"
+    "react": "^18.3.0",
+    "string-width": "^7.2.0"
   },
   "devDependencies": {
     "@biomejs/biome": "^1.9.0",