Keelokit

Keelokit Keelokit Harbor v0.1.0 · released

Sessions that can’t see each other. One convoy. One push to main.

Harbor is the meta-orchestrator of releases. Sessions in Claude Desktop, in the CLI and in the cloud, on several accounts, cannot see each other. Each one finishes its work on its own branch, and Harbor brings it together as coordinated, verified releases: a skipper gathers the batch, it is verified once, and after the harbormaster’s ok it lands on main in one push, in order.

I built it from hundreds of hours, thousands by now, of running many sessions at once and needing them to keep delivering with almost no intervention. It is opinionated and built around how I work, so take what’s useful.

What it does

A logbook every session reads, accounts and workers, seals, convoys from new to sail, the harbormaster’s watch, fresh reads before every decision, and a one-time import of an existing BOARD.md.

What it needs

Keelokit 0.12.0 or later in the project, Python 3.11+, git and a remote origin.

How to get it

From the marketplace (claude plugin marketplace add leosimini/keelokit-harbor), or the zip from the latest release.

−2 m

One landing per story doesn’t scale.

Keelokit builds one story per session and lands it on main after a local verify. With sessions that don’t depend on each other, that is the right amount of process. When orchestrating gets complex, with sessions on more than one account, machine or tool, three costs show up.

  1. 01

    A full verify per landing

    Every story repeats the whole check before it is pushed, whatever else is already waiting.

  2. 02

    Nobody sees the combination

    Two branches can each be green and break each other. You find out when both are on main.

  3. 03

    A CI run per push

    Each push to main starts CI. Where CI is billed, every landing is a bill.

Keelokit aloneThe sailboatOne story, one verify, one push to main.
Keelokit + HarborThe convoyMany vessels, one verify of the whole, one push to main.

−4 m

From a sealed vessel to one push.

A convoy is the branch convoy/<n>: main and the vessels, merged. It goes through five stops, and the logbook records each one.

  1. 1assembling

    A vessel enters

    convoy add. The branch comes with its exact commit and a green seal for that commit.

  2. 2waiting → ready

    The skipper assembles

    convoy assemble. main and the vessels are merged into convoy/<n>, migrations in order.

  3. 3verifying

    The harbormaster’s ok

    convoy sail --ok. It picks how much to verify, and why. Critical cargo also waits for your yes.

  4. 4verifying

    One verify

    convoy verify. The whole convoy, once, on its exact head. A fix is a new commit on convoy/<n>.

  5. 5sailed

    Into port

    convoy sail. One push to main, a fast-forward, never --force.

The tide

If main moves while you wait

The ok no longer holds, because it was given for other contents. Harbor merges the new main into the convoy, the harbormaster gives a new ok, and the convoy is verified again.

Harbor never rebases a convoy. Every move of main is written in the logbook with its cause.

−6 m

What Harbor takes off your hands.

Five rules that matter, written as checks instead of left to memory. Each one has its picture, and next to it, what really happens.

logbook

The ship’s logbook

The state is a git branch only Harbor writes, harbor/log: TOML files with a fixed schema and pages generated from them. It is never on main, so writing it does not move main or start its CI. Every session, account and machine reads it with git fetch.

seal

The container seal

A branch enters a convoy only with its exact hash and a verify result for that hash. A commit after that has no result, so the delivery is void until it is verified again.

hotspot

The narrow channel: one ship at a time

Paths you declare as shared (schema, migrations, shared types, locales). Two branches that touch the same one are never in open convoys together.

watch

The change of watch

One harbormaster at a time, with a heartbeat that expires. When it lapses, any session can take the watch, and the first commit wins.

account cap

A crew with room for so many on deck

Each Claude account has a cap on active sessions and a pause. At the limit, its sessions hand over what they pushed, with hashes, instead of leaving half-done work.

−8 m

The crew.

Four roles. The logbook is written by Harbor alone: nobody on board edits it by hand.

harbormaster

The harbormaster, on watch

One session at a time gives the ok to sail and picks the level of verify (changed or all), with its reason. It does not integrate and does not write code.

skipper

The skipper

The session that carries one convoy: takes the deliveries, merges main and the vessels into convoy/<n>, fixes the combination.

vessel

A vessel, small or big

One session’s branch, built with build-story. It enters with its exact commit and its seal.

convoy approve

The owner’s yes

A convoy with a full-tier story or a critical area also waits for your yes, typed in your own terminal and tied to that commit.

−10 m

If nothing needs orchestrating, you don’t need it.

  • Keelokit alone lands each story on main after its own verify. For one person, or sessions that don’t depend on each other, that is less to run.
  • Keelokit’s coordinate skill already covers parallel sessions that don’t collide, without convoys.
  • Harbor changes how work lands. With it adopted, build-story stops at its own branch and the convoy does the landing. It is not a mode you mix with direct landing in the same repo.

Which one do I need?

−12 m

−14 m

Try it

You need Keelokit 0.12.0 or later in the project (.keelokit/), Python 3.11+, git and a remote origin.

Install it from the marketplace, in Claude Code:

 claude plugin marketplace add leosimini/keelokit-harbor claude plugin install harbor@keelokit-harbor

Then run /harbor:adopt in a Keelokit project.

Or download harbor-plugin.zip, the plugin ready to install: in Claude, Customize → Plugins → Upload.

Download the latest versionCode, docs and license on GitHub

How it works, in detail

MIT license.