zidane 5.14.4 → 6.0.0

package/docs/SKILL.md

@@ -803,6 +803,22 @@ On session resume, `skills_use` calls in the turn history rebuild the active set
 
 Programmatic host-side activations (`agent.activateSkill(name)`) do NOT produce a `skills_use` block in history, so they don't survive the run-end deactivate-all pass automatically. Hosts that want persistence across runs (TUI slash-commands, for example) must re-activate before each `agent.run()`; the TUI does this via a pinned-skills set persisted in `session.metadata['zidane.activeSkills']` — see `docs/TUI.md`.
 
+### Installing skills (GitHub / npm / skills.sh)
+
+```ts
+import { installSkillFromSpec } from 'zidane'
+
+await installSkillFromSpec({ source: 'vercel-labs/agent-skills', skill: 'react-best-practices', scope: 'user' })
+await installSkillFromSpec({ source: 'https://skills.sh/anthropics/skills/frontend-design', scope: 'project' })
+await installSkillFromSpec({ source: 'owner/repo#main:skills/foo', scope: 'user', preferSkillsCli: false })
+```
+
+Shares the extensions installer's source layer: `owner/repo[#ref][:subdir]`, GitHub URLs (incl. `/tree/…`), `pkg[@version]`, `@scope/pkg` — plus pasted `skills.sh/<owner>/<repo>[/<skill>]` catalog URLs (skills.sh uses GitHub as its registry, so both engines cover the same universe). Engine selection: the **skills.sh CLI** when `skills` is on PATH (installs to the cross-agent `.agents/skills/`, feeds their lockfile/leaderboard; `-y` non-interactive, user scope maps to `-g`), else the **native fetch** into `~/.zidane/skills/<name>` or `<gitRoot>/.zidane/skills/<name>` — both already on the default scan paths. `preferSkillsCli: false` forces native.
+
+Unlike extensions, validation **never executes code** — candidates are validated by parsing `SKILL.md` (the same lenient parser discovery uses). Candidate discovery is a bounded recursive walk: **any** directory containing a `SKILL.md` (up to 4 levels deep, dot-dirs/`node_modules` skipped, never descending into a skill's own subtree) — so flat collections, `skills/<name>/`, and nested category layouts (`skills/engineering/<name>/`) all work. Multi-skill repos throw `multiple-candidates` carrying root-relative paths; `skill` selects by bare name or, when names collide across categories, by path (`skill: 'engineering/tdd'`). Same hardening as extensions: staged fetch, physical symlink containment for `:subdir`, overwrite (opt-in) with backup/rollback, and a `.zidane-install.json` provenance sidecar (`readSkillProvenance`). Errors are typed `SkillInstallError`s with `.code`.
+
+In the TUI: **Settings → Skills → `ctrl+g`** (source → scope flow, same gesture as the Extensions tab). Settings → MCPs has the matching `ctrl+g` add-server form (writes the scope's `mcps.json`, shape-preserving upsert).
+
 ### Lenient load, strict authoring
 
 Third-party skills with minor deviations load anyway via `parseSkillFile` (warnings in `SkillConfig.diagnostics`). `defineSkill` / `writeSkillToDisk` run `validateSkillForWrite` — spec-strict.

package/docs/TUI.md

@@ -190,18 +190,21 @@ Every customizable shortcut routes through `<userDir>/keybindings.json` and is p
 | `esc` | — | run in flight / approval pending | abort run + drain approval + interaction queues |
 | `esc` | — | modal open | close modal |
 | `ctrl+o` | `openSettings` | non-auth | open Settings modal |
-| `ctrl+x` | `openSessionDetails` | chat (idle) or sessions list (focused row) | open session-details modal |
+| `ctrl+shift+x` | `openSessionDetails` | chat (idle) or sessions list (focused row) | open session-details modal. Kept off `ctrl+x` (conventional "cut"); needs the kitty keyboard protocol to stay distinct from it — rebind on legacy terminals like Terminal.app |
 | `ctrl+m` | `openModelPicker` | chat (idle) | open cross-provider model picker |
 | `ctrl+l` | `openEffortPicker` | chat (idle, model has reasoning) | open reasoning-effort picker |
 | `ctrl+s` | `enterSelectTurnMode` | chat (idle) | enter select-turn mode (transcript navigation) |
 | `ctrl+t` | `openTodos` | chat (session attached) | open the active run's `todowrite` checkpoints (read-only) |
-| `ctrl+g` | `openContextPanel` | chat | open the context-usage breakdown panel (read-only) |
+| `ctrl+shift+g` | `openContextPanel` | chat | open the context-usage breakdown panel (read-only). Needs a terminal with the kitty keyboard protocol to stay distinct from `ctrl+g`; rebind on legacy terminals like Terminal.app |
 | `ctrl+y` | `openKeybindings` | non-auth | open the keybindings panel — read-only catalog grouped by surface, with `↵` to edit `~/.zidane/keybindings.json` |
 | `ctrl+k` | `cancelToolCall` | chat (busy, ≥1 in-flight call) | open the cancel-tool picker — pick one call to flip via `agent.cancelTool(callId)`, or press `a` to cancel every in-flight call. Distinct from `esc abort` (whole-run abort); siblings keep running |
 | `ctrl+v` | `attachClipboardImage` | textarea | attach an image from the OS clipboard. Reads via a platform helper (`pngpaste` or an `osascript` fallback on macOS; `wl-paste`/`xclip` on Linux; PowerShell on Windows). An empty bracketed-paste event also probes the clipboard for an image. Soft-fails with an inline notice (no image / helper missing / over SSH / too large). Gated on `attachmentsEnabled` |
+| `ctrl+g` | `openExternalEditor` | textarea | open the current prompt draft in `$EDITOR` / `$VISUAL` (git-style: temp file, reloads on save & quit). Suspends the renderer for the editor; a non-zero editor exit aborts (prompt unchanged). Gated on `externalEditor` |
 | `shift+tab` | `cycleAgent` | chat (idle, ≥2 profiles) | cycle to next agent profile |
 | `ctrl+↵` | `pushQueuedMessage` | queue-selection mode | push selected queued message into the live run |
 | `backspace` | `dropQueuedMessage` | queue-selection mode | drop selected queued message |
+| `pageup` / `pagedown` | (transcript scroll) | chat (no modal) | scroll the transcript one full page up / down |
+| `shift+pageup` / `shift+pagedown` | (transcript scroll) | chat (no modal) | jump the transcript to the very top / bottom |
 | `ctrl+a` | (textarea built-in) | textarea | select-all (use `home` / `ctrl+e` for emacs-style line ends) |
 
 ### Modal-internal shortcuts
@@ -360,7 +363,7 @@ Both surfaces resolve "what list to show" via `useActiveTodos(session)`, which c
 
 ### Context-usage panel
 
-- **`ContextPanelModal`** (`src/tui/context-panel.tsx`) — opened via `ctrl+g` (`openContextPanel`), closes on `esc`. Read-only, on-demand: the `App.tsx` handler calls `agent.getContextBreakdown({ model, effectiveWindow, autocompactBuffer, compactThreshold })` (see [Context-usage breakdown in CHAT.md](./CHAT.md#context-usage-breakdown)) and opens the modal with the result — guarded so a stale async resolve (session switched mid-fetch) doesn't pop a panel for the wrong agent. Renders a single full-width stacked bar (one fixed-hue segment per live category, the autocompact-buffer zone pinned at the tail from the threshold to the window end, free space as the remaining track) above per-category rows (swatch · label · token count · percent). Estimated rows carry a `~` prefix; the footnote `~ estimated — exact counts unavailable for this provider` shows only when ≥1 live category is heuristic. Below the categories: an "active skills" section (informational — an activated skill's body lives in the conversation, already counted there) and a "last turn" section with the exact cache-read / cache-write / fresh-input / output split from `TurnUsage`. Expandable rows (MCP tools, per-rule files) toggle with `↵`/`space`; `↑↓` move the cursor across expandable groups. The panel works before the first message via the agent's skills-only pre-run assembly. The bar palette is shared verbatim with the GUI popover so both surfaces read identically.
+- **`ContextPanelModal`** (`src/tui/context-panel.tsx`) — opened via `ctrl+shift+g` (`openContextPanel`), closes on `esc`. Read-only, on-demand: the `App.tsx` handler calls `agent.getContextBreakdown({ model, effectiveWindow, autocompactBuffer, compactThreshold })` (see [Context-usage breakdown in CHAT.md](./CHAT.md#context-usage-breakdown)) and opens the modal with the result — guarded so a stale async resolve (session switched mid-fetch) doesn't pop a panel for the wrong agent. Renders a single full-width stacked bar (one fixed-hue segment per live category, the autocompact-buffer zone pinned at the tail from the threshold to the window end, free space as the remaining track) above per-category rows (swatch · label · token count · percent). Estimated rows carry a `~` prefix; the footnote `~ estimated — exact counts unavailable for this provider` shows only when ≥1 live category is heuristic. Below the categories: an "active skills" section (informational — an activated skill's body lives in the conversation, already counted there) and a "last turn" section with the exact cache-read / cache-write / fresh-input / output split from `TurnUsage`. Expandable rows (MCP tools, per-rule files) toggle with `↵`/`space`; `↑↓` move the cursor across expandable groups. The panel works before the first message via the agent's skills-only pre-run assembly. The bar palette is shared verbatim with the GUI popover so both surfaces read identically.
 
 In addition, every `todowrite` tool call in the transcript renders a small "what's in progress" sub-list directly beneath the formatted call line. The sub-list reads the call's `input.todos` payload (the checkpoint the model just wrote), filters to `status === 'in_progress'`, and prints one indented `◐ <content>` row per item. Hidden when the payload has no in-progress items (e.g. all-completed close-out) so the transcript stays tight. This is purely declarative — it reads the event's own payload, not session state, so it's stable across re-renders and matches what the model intended at that checkpoint (not the latest list state, which the indicator + modal already surface).
 
@@ -437,6 +440,10 @@ Two scroll effects layer on top, both keyed off React state:
 
 The two coexist — selecting a turn jumps to it; exiting select-turn mode (`esc`) plus the next streamed delta re-engages the native sticky-bottom.
 
+**Scrollback is memory-bounded.** Every rendered transcript event keeps live renderables + native buffers even off-screen (~0.13MB RSS each, measured), so an unbounded array OOMs long sessions. `capTranscriptEvents` (`chat/streaming-pure.ts`) trims the display to the newest ~1,200 events (cap 1,500, turn-boundary-safe) with a cumulative "… N earlier transcript items hidden" marker at the top — session turns on disk stay complete, and re-activating the session replays the newest window again. Applied on every stream-drain commit and at every `eventsFromTurns` replay site; embedders can tune or disable it via `StreamBufferOptions.maxTranscriptEvents` (`null` = unbounded, pre-cap behavior).
+
+**Large markdown is chunk-rendered.** OpenTUI's `<markdown>` runs marked's lexer, which is quadratic over paragraph-heavy input (~6s for one 256KiB block). `MarkdownBlock` splits documents past ~24KiB into sibling renderables at fence-aware, list-safe blank-line boundaries (`chunkMarkdownForRender`) — visually equivalent, linear cost, single-element fast path for normal replies.
+
 `Settings.smoothStreaming` (default **on**) drip-feeds streamed text at a smooth cadence (typewriter) instead of in stream bursts; the auto-pin loop tracks each delta naturally because each tick still grows the scrollbox content.
 
 ## Select-turn mode

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zidane",
-  "version": "5.14.4",
+  "version": "6.0.0",
   "description": "an agent that goes straight to the goal",
   "type": "module",
   "private": false,
@@ -171,6 +171,11 @@
       "import": "./dist/skills.js",
       "default": "./dist/skills.js"
     },
+    "./extensions": {
+      "types": "./dist/extensions.d.ts",
+      "import": "./dist/extensions.js",
+      "default": "./dist/extensions.js"
+    },
     "./restate": {
       "types": "./dist/restate.d.ts",
       "import": "./dist/restate.js",
@@ -220,7 +225,8 @@
   ],
   "workspaces": [
     "tui",
-    "tui/npm/*"
+    "tui/npm/*",
+    "extensions/*"
   ],
   "engines": {
     "node": ">=20"
@@ -231,6 +237,7 @@
     "acp": "bun run src/acp-cli.ts",
     "headless": "bun run src/headless-cli.ts",
     "tui": "bun --cwd=tui run dev",
+    "tui:executable": "bun --cwd=tui run dev:executable",
     "tui:install:cross": "bun install --cpu='*' --os='*'",
     "tui:build": "bun run scripts/build-executables.ts",
     "tui:build:current": "bun run scripts/build-executables.ts --current",
@@ -240,6 +247,8 @@
     "smoke:package": "bun run scripts/smoke-package-exports.ts",
     "smoke:bundle": "bun run scripts/smoke-bundle-size.ts",
     "test": "bun test",
+    "test:extensions": "bun test ./extensions",
+    "typecheck:extensions": "for d in extensions/*/; do tsc --noEmit -p \"$d\" || exit 1; done",
     "test:inference": "cd test-inference && bun test",
     "test:eval": "bun run scripts/eval.ts",
     "restate:fixture:up": "docker compose -f test/fixtures/restate-docker/docker-compose.yml up --build -d",
@@ -324,7 +333,7 @@
     "e2b": "^2.27.1",
     "eslint": "^10.2.1",
     "jiti": "^2.6.1",
-    "react": "^19.2.0",
+    "react": "^19.2.7",
     "tsdown": "^0.22.0",
     "typescript": "~6.0.3"
   }