Skip to content

Releases

duobrain v0.1.9

Choose a tag to compare

@github-actions github-actions released this 05 Oct 07:13

duobrain v0.1.9

Chart tokens for the pages you build next to duobrain — a manual for a specific task, a data-analysis or
data-tracking dashboard — so your charts use duobrain's colors instead of a palette of their own. In the
product repository, run:

npx duobrain@0.1.9 install

Design tokens: added --duo-chart-series-1–5, --duo-chart-other, --duo-chart-single, --duo-chart-highlight, --duo-chart-highlight-line, --duo-chart-sequential-1–5, --duo-chart-diverging-negative, --duo-chart-diverging-neutral, --duo-chart-diverging-positive, --duo-chart-grid, --duo-chart-axis, --duo-chart-label, --duo-chart-empty, --duo-chart-line-width, --duo-chart-line-width-detail, --duo-chart-marker-size, --duo-chart-bar-radius, --duo-chart-gap

Added

  • Chart colors from duobrain's palette. Series 1 and 2 are the two people's colors, so a two-person
    chart needs nothing else; series 3–5 are terracotta, steel blue and olive, and anything further folds
    into a gray --duo-chart-other. All five clear 3:1 on white and stay apart for color-blind readers;
    charts where any two colors can touch, such as scatter plots, read well up to three series.
  • One series, one highlight. --duo-chart-single draws a series in charcoal and
    --duo-chart-highlight lights the mark that matters — this week, or you — in lime.
  • Scales. A lime-to-forest sequential scale for how much (start at step 2 for ordered steps such as
    stages) and a terracotta / steel-blue diverging pair around a neutral midpoint.
  • Chart chrome and marks. Gridlines, axis and label colors that reuse the dashboard's line and text
    tokens; 2px lines, 1px detail lines, 8px points, 4px rounded bar ends and a 2px gap between fills;
    --duo-chart-empty for heatmap cells with nothing recorded.
  • Samples on the tokens page (/tokens): a short line chart with labels at the line ends, bars with a
    lime highlight, a 90-day chart with raw values in thin gray and each person's 7-day average, and a
    year heatmap with one cell per day.

Changed

  • Between releases, npm run release:check only requires the Design tokens: line, so CI stays green
    while tokens change; the comparison with the previous release tag still runs when a release is cut.
  • The npm publish workflow fetches tags, which that comparison needs.

No existing token changed, so pages built on 0.1.8 keep their look. Nothing in the work record changed,
so a partner on 0.1.8 keeps working. See
docs/design-tokens.md
for how to use the chart tokens.

Verification

The suite contains 135 tests. The chart colors were checked with a color-blind simulation (worst adjacent
separation 9.6, target 8) and for 3:1 contrast on white; the sequential scale reads one hue, light to
dark, with its ordered steps clearing 2:1.

duobrain v0.1.8

Choose a tag to compare

@github-actions github-actions released this 05 Oct 06:44

duobrain v0.1.8

When the two of you build something next to duobrain — a manual for a specific task, a dashboard of what
you delivered — you can now reuse its UI without making design tokens of your own. The dashboard's look is a
published set of --duo-* tokens, and every release says whether they changed. In the product repository, run:

npx duobrain@0.1.8 install

Design tokens: introduced (73 tokens)

Added

  • tokens.css. 73 --duo-* CSS custom properties: colors by role (surfaces, text, sidebar, lime
    accent, the two people, status), type (fonts, sizes, weights, leading, tracking), a 4px spacing scale,
    radii, shadows and layout widths. Load it from .duobrain/src/dashboard/public/tokens.css,
    node_modules/duobrain/src/dashboard/public/tokens.css or a running dashboard at /tokens.css.
  • Tokens page. tokens.html (open the file, or /tokens on a running dashboard) lists every token
    with its value and the dashboard elements that use it, then draws each element with the real styles
    next to the tokens it reads. Click a name to copy var(--duo-…).
  • A promise about names. Within 0.x.y a token is never renamed or removed; renames happen only in a
    new minor version, with the old name kept as an alias for that version. The paths above stay the same.
  • A line about tokens in every release note from now on, like the one above. release:check compares
    tokens.css with the previous release and refuses a note that does not match, or a patch release that
    removes a token. node scripts/token-changes.mjs <previous-tag> prints the line.

Changed

  • The dashboard's stylesheet is built only from these tokens. Spacing moved onto the 4px scale and
    near-identical colors were unified, so a few gaps are 1–4px wider, buttons and tabs are slightly
    rounder, and the sample-data banner uses the same amber as paused badges.
  • Variable names from before 0.1.8 (--bg, --ink, --lime, …) still work as aliases until 0.2.0.

See docs/design-tokens.md for
the token groups, naming and stability rules. Nothing in the work record changed, so a partner on 0.1.7
keeps working.

Verification

The suite contains 135 tests, including checks that the dashboard reads only defined tokens and no
literal colors or sizes, that tokens.html matches the current styles, and that the token pages are
served under the dashboard's content security policy. The release check was exercised against a
mismatched line, a matching line and a token removed in a patch release.

duobrain v0.1.7

Choose a tag to compare

@github-actions github-actions released this 05 Oct 00:30

duobrain v0.1.7

Records are written to be found, and an agent finds them in one step. In the product repository, run:

npx duobrain@0.1.7 install

Added

  • find. One structured query (--query in the user's words, plus --intent, --expand,
    --entities, --exclude, --kinds, --limit, or --file <json>) looks through wiki notes,
    tickets and session handoffs along two channels at once:

    • search matches words with BM25F (title and keywords weigh most, Korean is compared in
      two-character pieces, English is lightly stemmed), then judges by rule: a superseded note drops
      and its replacement rises, evidence for an open or named ticket rises, a summary folds in its
      sources, and the list stops at the first steep score drop. At most a few cards come back, each
      with why it matched, plus match: strong | weak | none.
    • browse lists every other record as one short line (title, status, date, short abstract),
      newest first, at most 100, so the agent can pick by meaning what word matching missed.
      --no-browse omits it.

    No bodies are returned. Cards link notes and tickets both ways (evidenceFor, evidence).

  • wiki-get --path wiki/<id>.md and ticket-get --ticket <id> open one record in full.

  • Search metadata on notes. A wiki note may carry abstract (one or two sentences) and
    keywords (up to 12, in every language the team uses, with entities and the questions it
    answers). Notes without them stay valid; note-add reports searchMetadata.missing.

  • Wiki in the briefing. status --brief shows the evidence notes of my open tickets (up to 5)
    and notes others recorded after my last handoff (up to 3), as cards without bodies.

Changed

  • wiki-list returns cards without bodies. wiki-list --full returns every note as before.
  • The AI guide's lookup limit is now: briefing, one find judged across both channels, at most two
    opened records (in a sub-agent when available), then unknown and a ticket. Lookups are answered
    in four lines with a quoted line from the record.

Compatibility

No new events and no migration. Engines on 0.1.6 ignore abstract and keywords, so partners can
update one at a time. wiki-search is unchanged.

Upgrading

node .duobrain/bin/duobrain.js update moves a vendored copy to v0.1.7; the partner pulls.

Verification

Unit tests cover the search metadata, both channels, Korean and English word forms, supersession,
ticket evidence, summary folding, the cutoff and none. A two-clone test drives find, wiki-get,
ticket-get, wiki-list and the briefing through the CLI.

duobrain v0.1.6

Choose a tag to compare

@github-actions github-actions released this 04 Oct 13:44

duobrain v0.1.6

The first duobrain release published on npm. In the product repository, run:

npx duobrain@0.1.6 install

Fixed

  • Updates from an npm install. npm publishes repository.url as git+https://…. install copied it
    into VENDOR.json as the update source, and Git cannot fetch a git+https URL, so update from an
    npm-installed copy would have failed. install now records the plain Git URL, and update also
    accepts a source that still carries the prefix. v0.1.5 was found to have this problem before it was
    published to npm, so it is available from Git only.

Upgrading

Nothing changes for copies installed from Git: node .duobrain/bin/duobrain.js update moves to v0.1.6.

Verification

A new test installs from an npm-style copy (no .git, git+ repository URL) and checks that
VENDOR.json records the plain source and that update --check reaches the release tags.

duobrain v0.1.5

Choose a tag to compare

@github-actions github-actions released this 04 Oct 13:21

Note: v0.1.5 was not published to npm: a copy installed from its npm package would not have been able to run update. npm releases start at v0.1.6. Installing v0.1.5 from Git works.

duobrain v0.1.5

duobrain is now on npm. The first person adds it to a project with one command, without cloning the
duobrain repository first.

Changed

  • Install with npx. In the product repository, run npx duobrain@0.1.5 install. It vendors the same
    runtime files into .duobrain/ and pins v0.1.5 in VENDOR.json, exactly like an install from a Git
    download. Nothing is installed globally. Installing from a Git download still works.
  • Updates are unchanged. update in a vendored copy keeps installing from the Git release tags, so a
    copy installed from npm and one installed from Git update the same way. The partner still only pulls.
  • The npm package contains only what install vendors: bin, src, guides, skills, package.json,
    LICENSE and README.md.
  • The README and Getting started guide drop the "local alpha" label.

Upgrading

Nothing to do for existing projects: node .duobrain/bin/duobrain.js update moves a vendored copy to
v0.1.5 as before.

Verification

npm run release:check now checks that package.json is publishable and that its files match the
runtime files install copies. The package was packed with npm pack and installed into a fresh
product repository with npm exec, then init, status --brief and update --check ran from the
vendored copy.

duobrain v0.1.4

Choose a tag to compare

@github-actions github-actions released this 03 Oct 17:47

duobrain v0.1.4

Updating duobrain now takes one step for the person who updates and none for their partner beyond a
pull: update commits the new copy, and the partner is told to pull until both run the same version.

Changed

  • update commits the vendored copy. After replacing .duobrain/, it commits only that folder (and
    any agent file it rewrote) as chore: update duobrain to vX.Y.Z. Anything else you had staged stays
    staged and out of the commit. Push as usual. --no-commit skips the commit, and if a commit hook fails
    the files are left ready to commit by hand.
  • AGENTS.md stops changing between releases. For a vendored copy the product's AGENTS.md block is
    now a fixed pointer to .duobrain/AGENTS.md, and the agent instructions travel inside .duobrain/.
    The block changes once, on the update to v0.1.4, and then stays the same.
  • The newest code finishes every update. update hands over to the newly installed code
    (update-finish), so later releases can change how updates are finished without waiting a version.

Added

  • Your partner is told to pull. Each update is added to the work record (tool.updated). Until the
    partner runs the same version, their dashboard shows Mina updated duobrain to vX.Y.Z. Pull the project… with the update commit, and their AI sees duobrainUpdate in status --brief. Pulling makes
    it disappear; there is nothing to answer or close. With an own duobrain checkout instead of
    .duobrain/, the notice says to update rather than pull.
  • The dashboard's update result shows the commit to push, notes that the partner will be told, and,
    when the partner already updated, suggests pulling instead of updating a second time.
  • Snapshot tools lists each participant's latest recorded version; GET /api/meta also reports whether
    the running copy is vendored.

Upgrading from v0.1.3 or earlier

The update to v0.1.4 itself still runs your current version's code, so commit it once by hand:

node .duobrain/bin/duobrain.js update
git add .duobrain AGENTS.md && git commit -m "chore: update duobrain to v0.1.4"
git push

From v0.1.4 on, update commits and notifies on its own. Engines before v0.1.4 ignore the new
tool.updated records, so a partner still on an older version keeps working; they only see the notice
once they run v0.1.4 or later.

Verification

The suite contains 113 tests. The vendored end-to-end test installs a release, updates it, checks that
only .duobrain/ is committed while an unrelated staged file stays staged, that AGENTS.md is unchanged,
and that the partner's status --brief reports the update after sync and drops it after pull.

duobrain v0.1.3

Choose a tag to compare

@github-actions github-actions released this 03 Oct 17:00

duobrain v0.1.3

The dashboard becomes a two-person board you can keep open: who is on what, whose turn each request is,
and how the work flowed — plus updating duobrain without leaving it.

Changed

  • New layout. A charcoal-and-lime sidebar holds Now, Requests, Flow and Wiki, shows both
    people's current state on every tab, and collapses to icons. Narrow windows switch to icons on their own.
  • Now leads with the shared goal and plan state, then a card per person (working on, up next, stuck on)
    and open requests written as sentences with whose turn it is.
  • Requests pairs request cards with a detail pane (turn, progress, timeline, evidence). J / K move
    between requests.
  • Flow places sessions, request events and wiki notes in two lanes, one per person, in recorded order,
    next to recorded-time totals, blockers and per-area time.
  • The dashboard knows who you are. With --repository, the checkout's local identity
    (duobrain init --participant) marks your requests as Your turn, and the sidebar shows your profile
    nickname and GitHub login. Without an identity you pick yourself once in that browser.
  • Sharing status comes first. A card under the logo says whether your records reached your partner
    (Shared with partner · 5m ago, Not shared yet, Sharing failed) and when the page last re-read them.
  • English by default. The dashboard uses Korean only when the browser's first language is Korean; the
    sample data follows the same language.

Added

  • Update from the dashboard. Check for updates at the bottom of the sidebar compares versions, lists
    the new commits and asks before doing anything. It runs this copy's own duobrain update, so the same
    safety checks apply. Restart the dashboard afterwards; a vendored copy also reminds you to commit
    .duobrain/ and AGENTS.md.
  • Daily update check. Once a day the dashboard quietly checks for a new release and turns the sidebar
    button into a lime Update to vX.Y.Z. It never installs on its own and can be turned off.
  • Settings tab for language (Automatic, English, 한국어), auto-refresh interval, sidebar labels and the
    running version.

Notes

  • The dashboard stays read-only for project records. The one exception is updating duobrain itself after
    you confirm, and that request is accepted only from the dashboard page (custom header plus matching
    Host and Origin), so other sites cannot trigger it.
  • New endpoints: GET /api/meta (running version) and GET/POST /api/update. Repository snapshots now
    include viewer, the local participant ID; no other local state is exposed.
  • The dashboard is local to this computer (127.0.0.1) and is designed for desktop windows.

Verification

The suite contains 112 tests, including update-request protection, error-code-only failure reports, the
local identity reaching the dashboard from a real engine store, and a guard against hard-coded Korean
outside the Korean dictionary.

duobrain v0.1.2

Choose a tag to compare

@github-actions github-actions released this 25 Sep 13:06

duobrain v0.1.2

A safety fix for projects that copied duobrain into a folder of their own. Upgrade if duobrain lives
anywhere inside your project other than .duobrain/.

Fixed

  • update could change your project. In v0.1.0 and v0.1.1, running update from a copy inside the
    project's repository (for example tools/duobrain) used Git on the enclosing project: it fetched the
    project and, when the project had its own package.json and a newer upstream commit, fast-forwarded the
    project's branch. It never discarded work, since it only fast-forwards a clean tree, but it moved the
    project without being asked. update now refuses with UPDATE_INSIDE_PROJECT.
  • install run from such a copy records the release as v<version> rather than the project's commit.

Added

  • install --no-agents vendors duobrain without writing AGENTS.md, CLAUDE.md or .gitattributes, for
    teams that maintain their own agent instructions.

If duobrain is in tools/duobrain or a similar folder

Do not run update from that copy with v0.1.0 or v0.1.1. Move to the vendored layout instead:

node tools/duobrain/bin/duobrain.js install      # add --no-agents to keep your own AGENTS.md
git rm -r tools/duobrain
git add .duobrain AGENTS.md CLAUDE.md .gitattributes
git commit -m "chore: vendor duobrain in .duobrain"
node .duobrain/bin/duobrain.js update

See Moving from a copied folder.

Verification

The suite contains 108 tests, including a regression test that reproduces the reported layout: a project
with its own package.json, duobrain copied to tools/duobrain, and a newer partner commit upstream.
update now refuses and the project branch does not move; install from that copy creates .duobrain.

duobrain v0.1.1

Choose a tag to compare

@github-actions github-actions released this 25 Sep 01:55

duobrain v0.1.1

One person adds duobrain to the project, and the other only pulls and joins.

Changed

  • Vendored install. install copies duobrain's runtime files (about 400KB, no dependencies) into
    .duobrain/ in the product repository and pins the release in .duobrain/VENDOR.json. It also writes
    the AGENTS.md block, the CLAUDE.md import and a .gitattributes line that marks the folder as
    vendored. Commit them once; the second person gets duobrain by pulling.
  • Joining. init --participant <id> reads the participant pair from the shared record, so the second
    person no longer repeats both IDs. Without shared state it fails before creating anything locally.
  • Updating. In a vendored project, update installs the newest vX.Y.Z release, or --ref vX.Y.Z,
    and refreshes AGENTS.md with the new code. One person updates and commits; the other pulls. It only
    moves to a newer version without --ref, and refuses to overwrite local edits in .duobrain/.

Why duobrain is vendored explains
the approach and its trade-offs. The global install from v0.1.0 (npm link, duobrain guide) still works.

Run

git clone --depth 1 --branch v0.1.1 https://github.com/slowspurt/duobrain.git /tmp/duobrain
cd /path/to/product
node /tmp/duobrain/bin/duobrain.js install
node .duobrain/bin/duobrain.js init --participants member-a,member-b --participant member-a

The other person, after pulling: node .duobrain/bin/duobrain.js init --participant member-b.
See Getting started.

Verification and limits

The suite contains 107 tests, including an end-to-end vendoring test: one clone installs and connects,
a second clone joins with only init --participant, and update installs a newer local release.
Release preparation also runs the three scenario checks against temporary Git repositories.

Actual acceptance with two people on separate machines and their existing AI tools remains pending.
Vendoring adds duobrain's files to the product repository; see the trade-offs in the vendoring guide.

duobrain v0.1.0

Choose a tag to compare

@slowspurt slowspurt released this 24 Sep 16:19

duobrain v0.1.0

duobrain gives exactly two people and their existing AI tools a shared project memory backed by Git.
This first release includes a local engine, read-only dashboard, and AI collaboration guides under the MIT license.

Included

  • Shared plans, roles, scoped sessions, overlap checks, and handoffs on an isolated duobrain/state branch.
  • Information requests with source evidence and human feedback requests with attributable responses.
  • Source-preserving wiki records, search, captured-method comparison, and on-demand wiki refinement.
  • Resumable AI-led onboarding and participant nicknames.
  • A dashboard organized into task tabs, in English or Korean from the browser language, with relative times,
    plain-language event labels, whose turn each open request is waiting on, and refresh while the page is visible.
  • AI setup through the product's AGENTS.md: init writes a managed block (imported by CLAUDE.md),
    guide resolves local paths, and agents-sync and update keep the block and the tool current.
  • A short English AI guide with on-demand references, and compact status --brief / overlap --brief output.
  • Commit work records: capture-extract, commit-note and the duobrain-commit skill store how and why
    each commit was made on duobrain/state, linked from a Duobrain-Record commit trailer.

Run

Requires Node.js 22+ and Git; no npm install is needed.

git clone --branch v0.1.0 https://github.com/slowspurt/duobrain.git
cd duobrain
npm link            # optional: puts `duobrain` on the PATH; nothing is installed
node bin/duobrain.js --version
node src/dashboard/run.js

Open http://127.0.0.1:4173 for sample records. To connect a real two-person project, follow
Getting started.
Keep the tool checkout separate from the product repository. Later versions install with duobrain update.

Verification and limits

The engine, wiki, dashboard, capture and tool suite contains 104 tests. Release preparation also runs
the concurrent-work, plan-refinement, and method-refinement scenarios against temporary Git repositories.
CI is configured for Node.js 22 and 24 on Linux and macOS; configuration alone is not a passing CI run.

Actual acceptance with two people on separate machines and their existing AI tools remains pending.
There is no background AI service, automatic partner wake-up, real-time lock, or scheduled wiki refinement.
The dashboard reads locally synchronized records; pending delivery requires sync retries.
Commit work records are written by the user's AI from the local Claude Code transcript; summaries can
contain mistakes and should be checked before committing. Other agents write the summary themselves.

Distribution is through GitHub source archives and Git checkout. No npm package is published.