windowsill

The coverage badge is the combined statements-and-branches figure for the plugins. It combines voice-loop's Linux, Windows and macOS coverage legs with sill-core's Linux legs; sill-core's Windows legs run the same 100% gate but upload no artifact, so they are tested and not counted.

Plugins and skills the saharkit agent school shares with everyone.

A windowsill is where you put things out for whoever walks past: tools that were built for real work, generalized until they are useful to someone else's machine. Everything here is packaged as a Claude Code plugin, installs in a couple of commands, and is meant to be read as well as run.

Add the marketplace

In your shell:

claude plugin marketplace add saharkit/windowsill

(or, from inside a running Claude Code session, the slash-command form: /plugin marketplace add saharkit/windowsill.)

Then install what you want from your shell:

claude plugin install voice-loop@windowsill   # voice-loop also needs sill-core — install both:
claude plugin install sill-core@windowsill

If you are already in a Claude Code session, the equivalent slash commands are /plugin install voice-loop@windowsill and /plugin install sill-core@windowsill.

Tester ritual

On a fresh machine, the complete marketplace check is:

claude plugin marketplace add saharkit/windowsill
claude plugin list --available --json

The second command lists what the marketplace makes available. claude plugin list with no flags lists installed plugins only, so an empty list on a fresh machine is expected — it does not mean the marketplace failed. Install the plugin from the shell (or use the equivalent slash command inside a session), then inspect the installed metadata:

claude plugin install voice-loop@windowsill

Back in the shell:

claude plugin details voice-loop

claude plugin marketplace info is not a command. There is also no details lookup for an uninstalled voice-loop@windowsill; before installation, clone the shelf and use the local path workaround instead:

git clone https://github.com/saharkit/windowsill
claude plugin details --plugin-dir ./windowsill/plugins/voice-loop

The in-repository relative sources are pinned by the shelf clone itself. The official catalog also pins third-party sources by commit reference and SHA; this shelf has no third-party source entries today.

For the machine-checkable half of the conformance pass, run the seeded eval cases after cloning:

claude plugin eval ./windowsill/plugins/voice-loop

They complement the human checklist in plugins/voice-loop/CONFORMANCE.md and the directory-readiness work tracked in #56 and #20.

Running on Windows

sill-core is CI-tested on native windows-latest — its atomic-write state store and remind-once logic run on Windows with the same 100% branch-coverage gate as Linux (the kill-9 crash-consistency tests are skipped; fcntl advisory locking is replaced with msvcrt.locking). The rest of the shelf — voice-loop's server, hooks, hotkeys, audio capture and playback — still depends on POSIX facilities (process groups, pkill, fcntl) and is not a native-Windows path. #42 tracks that work.

voice-loop also supports native Windows 11. Its hook and .cmd launcher probe for a real interpreter instead of trusting the Microsoft Store python3 alias; native dictation uses DirectShow, clip.exe, and PowerShell SendKeys. The voice-loop unit suite runs on windows-latest in CI. That CI leg is not a substitute for an attended microphone and speaker pass.

The documented Windows path for voice-loop is WSL2 with WSLg on Windows 11. If you want a native prerequisite install instead, the repository ships a Windows PowerShell recipe. From an elevated Windows PowerShell 5.1 in the cloned repository, run:

powershell -ExecutionPolicy Bypass -File .\plugins\voice-loop\scripts\install.ps1

It installs Python, Git, Node.js and Claude Code, then adds this marketplace. The recipe prints the remaining plugin commands and verifies installer exit codes; it is safe to re-run after opening a fresh PowerShell session. The bundled voice-loop server and audio hooks still use the WSL2 route below, so follow the printed setup instructions for the native prerequisites before continuing.

From an elevated PowerShell, install WSL2 with:

wsl --install

Restart if Windows asks, complete the distro setup, then open the WSL terminal. Inside the distro, use the ordinary Linux quickstart above: add the marketplace in the shell, install voice-loop (and its sill-core dependency), then run /voice-setup in a Claude Code session. WSLg is the Windows 11 integration intended to provide Linux GUI and audio-device access; an attended desktop session is required for microphone and speaker checks. If WSL reports a virtualization error, enable virtualization in UEFI/BIOS first.

A real WSL2 pass on Windows 11 24H2 (Ubuntu 24.04, WSL 2.7.11, WSLg 1.0.73.2) verified the marketplace install, the registered hook command, dictation with the CI-style fake recorder, and a lan loopback against a remote speech server. The hook contract ran with via=stream and two SSE chunks; live Claude Code hook dispatch, audibility and /voice-setup end to end were not measured. The loopback passed with an explicit --endpoint; a fresh distro without jq did not pass the config-driven form. Microphone passthrough was not exercised, so this page does not claim it. See the voice-loop WSL2 verification record and its WSL notes.

What is on the sill

plugin	version	what it does
agent-handbook	0.5.0	A handbook you hand to your agent — teaching material for the general judgement calls: architecture decisions, planning, the rules that hold whatever is being built. Not tied to a language, a stack or a build system; nothing installs a runtime, opens a network connection or needs hardware. It holds two kinds of thing. An instrument you reach for at a moment — /target-world-walk, a portfolio-completeness instrument: derive what a plan needs by replaying one concrete unit of work through the system you intend to have, instead of auditing the tickets you already wrote. It refuses a goal that points at a tracker item, classifies every need as covered / partial / missing / oral, and runs an ordering pass before anything is filed. And two standing rules that are never invoked at all — the flagellant rule, which reports a mistake as fact plus fix rather than apology, stops when the stopping condition is met instead of re-checking finished work, spends care where an error cannot be taken back, and reports completion only by first naming what would still be outstanding if it were wrong; and the non-stop rule, which says do the work and report it rather than asking permission, write in the past tense, never hand back the turn while work remains, ask a question only where the work becomes pointless or unsafe without the answer, probe your own rights with a command before saying a task needs a human, report done only with proof, and never write farewell summaries. Both rules arrive through a SessionStart hook, so they compose with whatever output style you have chosen rather than replacing it.	README
agent-statusline	0.2.3	One line at the bottom of Claude Code: how much of the context window is gone, how much of the weekly budget is spent, and which model is answering. Every figure is read from the payload the harness pipes to the script on stdin, so nothing is host-specific. Needs node and nothing else.	README
sill-core	0.2.0	Shared core for windowsill plugins: assistant state store with atomic writes and remind-once etiquette. Schema-versioned JSON persistence — one file per plugin in the user's state directory, separate from config.

Every plugin owns its own README, its own tests, its own docs and its own version — open its README for anything about it. More will land on the sill over time.

Not a plugin, but on the sill too:

	what it is
tales/	the shelf's story content — bedtime tales from the school, in Russian, some with a voiced edition. They never explain the machinery they came from: a tale hands you a fishing rod, not a fish.
ACHIEVEMENTS.md	the milestone ledger for the shelf and the school. Every row carries a date and a public proof link, and lands no earlier than the thing it claims — so a short page here means little has been earned yet, not that little is written down.

What a plugin brings to the shelf

Everything a plugin is lives under plugins/<name>/. The root belongs to the shelf, so a new plugin adds one directory and nothing else at the top level:

plugins/<name>/
  .claude-plugin/plugin.json   the manifest: name, description — and the version, which lives HERE
  README.md                    the plugin's own front page (the table above links to it)
  hooks/ scripts/ skills/      whatever the plugin actually ships
  tests/ + its runner config   its own suite, invoked from its own directory
  docs/                        its own deeper reading, if it needs any

The rules that follow from that:

• The version lives in plugins/<name>/.claude-plugin/plugin.json and is mirrored into .claude-plugin/marketplace.json and into the catalog row above. All three must agree, nothing else records a version, and no CI job checks the agreement — a bump touches all three or it is a review finding.
• Tests belong to the plugin. Its runner configuration (pytest.ini, .coveragerc, …) sits in its directory with paths relative to it, and the suite is invoked from there — plugins never share a test root, and adding one never disturbs another.
• The catalog row above is part of the plugin's own PR, together with its marketplace.json entry. A plugin that is not in the table is not on the shelf.
• CI is shared, per-plugin. One workflow in .github/workflows/ runs every plugin's checks; a new plugin adds its own jobs (or its own matrix entry) there rather than a second workflow — the shape to copy: scope every job with working-directory: plugins/<name> and prefix its job id with the plugin name so two plugins' checks stay distinguishable on a PR.

Root-level, and this is the whole list: this README (the catalog), .claude-plugin/marketplace.json (the manifest marketplace add reads), .github/ (shared CI), plugins/, tales/, ACHIEVEMENTS.md (the milestone ledger), LICENSE, .gitignore, CLAUDE.md (the passport an agent reads first) and .claude/ (its review-lens map).

Conventions (every plugin here follows them)

• Every plugin is testable without hardware. If a plugin talks to the world, it ships a loopback or contract test that CI can run on Linux, macOS, and (where native paths exist) Windows.
• The least-privilege path is the default path. Anything needing root or a system consent is an explicit opt-in, with the command printed rather than silently executed.
• Configuration lives in the user's config file, never in the code. No endpoints, keys or paths are baked in.
• Install is a skill, not a page of instructions. Where setup is fiddly, an agent does it and then proves it worked.

Privacy

Nothing here collects anything — no telemetry, no analytics, no accounts. Your voice goes only to the backend you configured, and bug reports are stripped and shown to you before anything is shared. The full page, with the receipts: PRIVACY.md.

Author

Sahar — AI engineer at saharkit.

License

MIT — see LICENSE.