Skip to content

LaBunbun Code 0.1.0.5 (Alpha)

Pre-release
Pre-release

Choose a tag to compare

@zayokami zayokami released this 16 Nov 13:38

LaBunbun Code 0.1.0.5 (Alpha)

The sixth public alpha of LaBunbun Code, a terminal coding agent with sandboxed
tool execution, provider migration, and offline binary inspection.

A drop-in replacement for 0.1.0.4 (Alpha 2). This release sizes every prompt
before the model sees it, runs the Windows read-only policy under an
AppContainer grant, summarizes a quiet session before its prompt cache expires,
puts compaction on the bill, adds five providers and the Claude Fable 5.2 /
Mythos 5.2 family, ships the built-in skills inside the binary, splits the
screen with Ctrl+T, reworks the approval and permission dialogs and the first
screen, asks for one of three phrases before arming /yolo, and lets / typed
through a Chinese input method open the command list.

What's new

Added

  • YOLO asks for one of three phrases. Arming YOLO from /yolo now picks
    one warning at random from I only live once, The World Is Yours., and
    Don't Panic., and the dialog shows only the one it picked. The typed answer
    must match that spelling exactly after trimming — case, apostrophe, and the
    final full stop included. The list lives in one place
    (YOLO_CONFIRMATION_PHRASES) and is exported for tests. See
    docs/dev/yolo-mode.md.

  • Windows enforces read-only without a native backend. A read-only policy
    that used to resolve refused on Windows now runs under an AppContainer
    grant that carries only FILE_READ_EXECUTE on every granted root — the
    workspace included — so the command can read the tree and run what it
    needs, and writes both inside the workspace and outside the grant fail.
    The grant gets its own profile name (labunbun-ro-<digest>,
    labunbun-net-ro-<digest>) so it never shares a refcounted identity with a
    write grant, and no .git narrowing is needed because the mask already
    refuses every write. Read-only with network: "restricted" still resolves
    refused: the container can only reach the restricted axis through a
    loopback proxy it cannot see. describeSandboxBackend says which of the
    two modes is in force. See docs/dev/sandbox.md.

  • The process scales to the request. Every user prompt is now read for its
    size before the model sees it: trivial (an explicit small cue such as
    just, typo, 只改), complex (scope words such as all, refactor,
    所有, or three named files), or standard. A trivial change is told to make
    the smallest edit, run the one check that covers it, and add no tests, docs,
    or defensive handling; a complex one to read first, state a short plan, and
    stop once the relevant checks pass. A question with no change verb — or only
    a negated one, as in "do not change anything, explain it" — is read as an
    answer, not an edit, while "don't forget to change it" stays a change; a
    question that asks for advice ("should I refactor this?", "该不该重构整个
    项目?") is an answer even when it names a change verb, while "can you fix
    it?" is still a request; a later imperative sentence makes the message a
    change ("why does it fail? fix it."), and so does a split request ("explain
    first, then fix it", "先解释一下,然后修复这个 bug"). The paths it counts
    ignore URLs and accept both separators, and a negated scope word adds nothing
    ("don't refactor everything, just fix the typo" stays trivial). standard
    adds nothing, so an ordinary request keeps the bytes and the effort it had.
    The same read sets thinking effort — low for
    trivial, high for complex — unless you set a level yourself. The
    instruction is part of the stored message, keeping the cache prefix stable,
    and is stripped from the transcript, the resume preview, export, and the
    requests a compaction keeps verbatim. LBB_TASK_SCALE=off turns it off. See
    docs/dev/task-scale.md.

  • The task scale reads negated requests and the bare Chinese verbs. 改 is
    back in the verb list (a regression from the split-request change), a bare
    不 now negates the verb after it, and 不得不 is not read as a negation. A
    polite request whose only listed verb is negated stays an answer ("Please
    don't refactor the entire codebase"), while a request with no listed verb is
    a change ("Could you enable the cache?", "Can you swap these two
    arguments?"). A question that only asks for an explanation still stays an
    answer.

  • The sandbox stops paying for scans that cannot change its answer. Write
    and Edit, and Bash outside workspace-write, no longer run the depth-4
    protected-path walk whose result they discard — 76 ms for the walk and a
    152 ms median per Bash call on Windows. workspacePolicy gains
    deriveProtectedPaths; the write guard already refuses .git at any depth,
    and the read-only and full-access policies discard the list anyway. Bash in
    workspace-write still re-derives it on every call, so metadata created
    mid-session is still protected.

  • A timed-out confined command takes its process tree with it. The Windows
    tree kill is now one helper (taskkill /T /F, with each caller's own
    fallback preserved), and the AppContainer runner calls it before
    TerminateProcess on both abort and timeout. A grandchild no longer keeps
    writing, locking files, or holding ports after the tool has reported failure.
    The normal-exit path is untouched.

  • A half-written compaction no longer erases the turn it kept. The boundary
    records the ids of the retained suffix messages. A load that finds only a
    strict prefix on the chain rolls the leaf back to the transcript the summary
    replaced, and the resume notice names it ("1 interrupted compaction rolled
    back to the previous transcript"). A write that fails mid-suffix leaves the
    live transcript on its old leaf, and a real branch inside the suffix is not a
    prefix, so a choice the user made is never read as a crash.

  • A quiet session summarizes before its cache expires, not after. The REPL
    now watches the main conversation's prompt cache and, once its entry is close
    to expiring, runs the summary while the prefix is still a cache read. The
    trigger is the provider's own lifetime — including a downgrade it announced —
    with a lead of up to two minutes; a provider whose cache is automatic and
    whose lifetime is not reported gets no pass at all, because there is no
    expiry to fire ahead of. The floor is the compaction threshold capped at
    200,000 tokens, the summarizer must share the session model's prefix identity
    or the request would pay full price, and a turn always wins: the pass never
    starts beside one, aborts when one starts, and does not adopt a summary that
    finished after a new message arrived. Its done line reads "Context
    compacted while idle", its failures stay silent (nobody was waiting), and it
    clears rather than counts the rapid-refill run. compaction.idleSummary: false turns it off; compaction.enabled: false still turns off the whole
    automatic side. See docs/dev/compaction.md.

  • Permanent failures stop retrying. TLS certificate errors, ENOSPC,
    EROFS, EACCES, and unsupported-protocol errors take the first-attempt
    terminal path instead of climbing the 10-attempt, 30-second-max ladder.
    Unknown status-less errors, ECONNRESET, 503, and the 529 cap keep the
    retries they had.

  • Malformed tool arguments fail before validation. A tool call whose
    arguments are not JSON is carried as a dedicated MalformedToolArguments
    value and answered before schema validation, validateInput, hooks, and
    permissions. A schema with no known keys (z.object({}), an MCP
    passthrough() schema) used to strip the old sentinel and run the tool with
    {}, reporting success. The error now names the JSON parse failure and a
    truncated raw excerpt, no tool starts, and the concurrency partitioner treats
    the call as serial without asking the tool.

  • Edit says what is actually wrong with its target. A cold-path Edit on a
    missing file answers "does not exist - use Write" instead of "was not read
    this session"; a directory and a permission failure are named the same way.
    A file that exists keeps the read gate it had.

  • Claude Fable 5.2 and Claude Mythos 5.2 are in the catalog. Both carry the
    1M-token window, 128K output, always-on adaptive thinking, and $8/$40 pricing
    with the 0.025x cache read. Their pages are the first to name all five effort
    levels, so xhigh and max now reach those two rows. The same notes state
    that the prefix check runs on every account, which also moves Mythos 5.1 into
    the rows that opt into dropping a mismatched thinking block. Fable 5.2 is
    pinned on OpenCode Zen and OpenRouter as well, and the fable migration alias
    resolves to it.

  • A logo. docs/assets/labunbun-logo.png is the new mark, shown at the top
    of the README.

  • The Windows build carries the mark. docs/assets/labunbun-icon.ico is the
    logo trimmed to its content, set on a white rounded square, and rendered at
    nine sizes from 16 to 256 pixels, so Explorer picks a sharp frame at every
    zoom. bin:build embeds it with --windows-icon and fills the executable's
    version resource — title and description LaBunbun Code, publisher
    zayokami, version 0.1.0.4, and the MIT copyright line — instead of
    leaving Bun's own metadata on the file. The installer takes its setup icon
    from the same file.

  • The system prompt adapts to the model family. Every session now resolves
    its model to a profile: Claude, GPT, Gemini, DeepSeek, Kimi, Qwen, GLM,
    MiniMax, Mistral, Meta, Hunyuan, MiMo, NVIDIA, a local Ollama model, or an
    unknown row. The profile adds a # Model guidance section naming the active
    model and carrying the family's tool and edit habits, and selects a short
    prompt for small windows and small local models. A gateway row is read as the
    model it serves, not as the gateway. /model rebuilds the prompt with the
    new model, and a subagent gets the profile of the model it actually runs on.
    The layer is per family, not per model, and it does not change thinking
    parameters, limits, or tool availability — those stay on the model row where
    the wire adapters read them. See docs/dev/model-profiles.md.

  • Five more providers: Tencent TokenHub, Xiaomi MiMo, Meta's Model API, and
    Kimi's China and Code hosts.
    tencent/ carries hy4, hy4-preview and
    hy3 from TokenHub, Tencent's official home for the Hy generation, keyed by
    TENCENT_API_KEY or TOKENHUB_API_KEY; hy4 also joins the OpenCode Go
    plan. xiaomi/ carries mimo-v2.6-flash and mimo-v2.6-pro on Xiaomi's
    pay-as-you-go host, keyed by MIMO_API_KEY or XIAOMI_API_KEY. meta/
    carries the six Muse models from api.meta.ai, keyed by META_API_KEY or
    the docs' MODEL_API_KEY. kimi-cn/ is the China platform's copy of the six
    Kimi API rows, and kimi-code/ and kimi-code-cn/ are the two region-locked
    Kimi Code plans, priced at zero because the plan bills a membership. Each
    regional host takes its own key (KIMI_CN_API_KEY, KIMI_CODE_API_KEY, or
    KIMI_CODE_CN_API_KEY) and cannot be reached with another region's. The
    Kimi cache floor applies to all three Kimi doors, /model discovers each
    provider's listing at startup, and every host can be moved with
    <PROVIDER>_BASE_URL.

  • /yolo turns off the permission gates for one session, with a typed
    confirmation.
    Typing /yolo opens a dialog that names what stops — the
    dangerous-command classifier, ask rules, and every approval prompt — and what
    remains: deny rules, hooks, the sandbox and its network policy, plan mode's
    read-only gate, tool validation, and MCP approvals. It takes the exact
    sentence I only live once, capitalisation included, to enable; a mismatch
    keeps the dialog open, and Escape cancels. The posture lives on the session
    only: it is not a permission mode, is not in the picker, the settings, the
    CLI or the policy snapshot, cannot be resumed, and ends with /yolo,
    /yolo off, any mode change, or a single Shift+Tab. Escalated Bash calls,
    which ask to leave the sandbox, are denied while it is on. Subagents and
    beetle members follow the root session live, and hosts without an interactive
    phrase surface cannot enter it. See docs/dev/yolo-mode.md.

  • The built-in skills ship inside the binary. Release artifacts carry the
    skill files from .labunbun/skills (bodies and references/) embedded in the
    executable instead of expecting a directory beside it. They are written once
    per version under ~/.labunbun/bundled-skills/<version>/ — a content digest
    rather than the version alone decides when to refresh — and loaded beneath the
    user's and the project's skills, so a local skill with the same name replaces
    the built-in one. bun run skills:bundle regenerates the import list;
    bin:build and release:package run it first.

  • Ctrl+T splits the screen when the terminal has room. On a terminal at
    least 88 columns wide and tall enough for two panes, the watch panel moves to
    a right column and the transcript takes the left one, with the prompt still
    under both — two live surfaces at once instead of one at a time. The
    transcript pane opens on the tail of the conversation, its header names the
    entries it is showing (Conversation 12-17 of 40), and PgUp/PgDn page it
    back and forward by the span the pane is showing. A page, once turned, stays
    put while new output arrives below, and the header counts it (· 3 new);
    paging back to the tail resumes following, and sending a message returns
    there. The right column carries the watch panel over a compact task strip —
    up to three unfinished tasks, an exact row budget — with one blank column
    between the panes. Ctrl+T or Escape closes the split. The terminal's
    scrollback above the frame is untouched and stays full width, so nothing is
    reprinted or lost. Narrow or short terminals keep the inline watch panel —
    the same key, one honest placement rather than a squeezed split. The left
    pane is drawn by a line model that fits its rows exactly, after a measured
    ink 7.1.1 bug in which an overflowing fixed-height box merged and dropped
    rows; see docs/dev/split-pane-design.md. The panes share one height budget
    with the rest of the frame: a dialog or card takes the frame while it is open
    and the split returns unchanged afterwards, and queued-message rows are taken
    from the panes first, so the frame never grows past the terminal.

  • The approval diff marks the words that changed. A removed/added pair in
    the permission dialog keeps its line colour and draws the words that actually
    differ in bold, so const answer = 1; against const answer = 42; points at
    1 and 42 instead of asking the reader to compare the lines by eye. A pair
    with almost nothing in common stays one colour, and an unaligned body or a
    Write has no counterpart to pair with, so it is drawn as before.

  • The permission dialog has one-key answers. y allows once, n denies,
    and a takes the session's standing "don't ask again" answer when the list
    offers one. An escalated Bash call has no such row, and a there does
    nothing rather than promising a grant the engine would not honour. The legend
    names y and a; Esc already stands for deny.

  • The first screen folds its startup notices into one dim line. Notices
    that used to print raw between the greeting and the prompt — a controller
    that is not attached, skill folders that failed validation, a catalog refresh
    — are summarised under the greeting (ℹ gamepad idle · skill not loaded · /doctor for details). None of them needs an answer before the first prompt,
    and unboxed between the two things that do, they read as a broken start.
    /doctor prints the full sentences after its health rows. A notice that
    carries something to act on still gets its own transcript row, and one that
    arrives after the conversation has started is said there instead, because
    there is no greeting left to fold it into.

Changed

  • A Windows command joins an installed sandbox grant instead of rewriting
    the ACLs.
    The last release of an AppContainer grant no longer tears the
    ACEs down immediately: it arms a 120 s idle window, and the next command in
    the same workspace finds the grant in the map and joins it. The ACL work is
    the expensive part of a confined Windows command — an inheritable ACE walks
    the whole subtree on the way in and its removal walks it on the way out,
    measured at 1.3–3.1 s for a 300-file workspace with a 3,000-object .git —
    and a join is one map lookup. The window ends on an unref'd timer, which
    runs the same teardown an immediate release does; a process that exits
    inside it leaves the reusable ACEs a crash already leaves. Shutdown flushes
    every idle grant. A grant a command still holds is refused for new roots
    exactly as before, and an idle grant is replaced instead, so the window
    never changes which commands the policy lets run.

  • Interactive mode says why it needs a terminal. When stdin is not a TTY
    (a pipe, a CI step, a launcher that captures output), the session now exits
    before the first frame with a message pointing at -p "<prompt>", instead of
    drawing the screen and then failing in the renderer — which looked like a
    flash and a crash.

  • The empty screen introduces itself. A session with no messages now opens
    on a welcome panel instead of a bare prompt: the mascot and
    Welcome to LaBunbun Code with the version under it on the left, a short
    Tips for getting started column on the right, and the workspace and model
    underneath. The panel measures the terminal and steps down — two columns, then
    one, then the name alone — and is not drawn at all below 34 columns or 14 rows,
    so the prompt always fits. It leaves the screen once someone has written to the
    transcript — startup notices underneath it do not count — or a turn, dialog or
    overlay is active.

  • The first screen is quieter. The starting interactive mode… line is gone:
    it stayed in the scrollback above the greeting, stating the same facts worse.
    Consecutive startup notices now print as one block rather than one blank line
    per row, which keeps the greeting, the notices and the prompt on a short
    terminal.

  • The prompt is a rounded box with a > in the margin. The writing surface
    reads as an input rather than an output log; the glyph carries the accent
    colour and multi-line drafts hang under it. The vim and permission badges and
    the key hint moved below the box, where they are a legend for the prompt
    instead of a second border inside it.

  • An answer has a margin of its own. Assistant prose now carries the same
    dot a tool call does, in a muted colour, with the body two columns in — so a
    reply, the code block under it and the tool row after it share one left edge,
    and a turn reads as one speaker's. The streaming preview uses the same gutter,
    so the answer does not shift left when the stream seals.

  • The prompt's legend tells the truth while a turn runs. The hint under the
    box said Enter send even mid-turn, when Enter steers the running agent (or
    queues, when it cannot be steered) and Tab queues behind it. It now names
    those meanings while busy and returns to the idle legend when the turn ends.

  • Two working directories no longer share one project key. The key was the
    absolute path with every :, / and \ folded to -, so /srv/a-b and
    /srv/a/b named one directory: sessions, project trust, MCP approvals, costs
    and tool output all landed in the same store. The key now percent-escapes
    those characters along with % itself, which is reversible and therefore
    distinct for every path. A session listed under the old key is moved to the
    new one when the cwd in its header matches, and a cost ledger under the old
    key is read once — but project trust and MCP approvals are not carried over:
    the old name cannot say which project granted them, so they are asked for once
    more rather than widening a grant to a neighbour.

Fixed

  • / reaches the command list through a Chinese input method. In Chinese
    punctuation mode the IME translates the / key before the terminal sees it:
    、 under Microsoft Pinyin, / under full-width punctuation. The buffer
    took the lookalike, it never matched the command prefix, and / read as
    dead — no list, no error, just a character that is not the one the user
    asked for. At an empty prompt those two characters are now stored as the
    half-width / and the list opens; mid-buffer they stay the characters
    typed, so 、 in a Chinese sentence is untouched.

  • A compaction's own request is on the bill. A summary is a full-prefix
    request — the most expensive one a session sends — and its message never
    enters the transcript, so every surface that costed the conversation from its
    messages alone reported the turns and omitted the compaction: a -p run's
    cost_usd, the ACP budget gate, and the REPL's /cost. Every attempt that
    came back with billed usage is now booked as it is spent, including an
    attempt the provider refused for size, one that answered with nothing, one
    the user cancelled, and the smaller request that replaced a refusal; the
    entry names the model that actually answered, not the summarizer that was
    asked when a fallback took over. A -p run's stream-json usage total
    carries the summary's tokens for the same reason its money does. A
    subagent's compaction books on the run's own seat, so the light ceiling sees
    it too.

  • A summary puts the turns it replaces on the bill too. A successful
    compaction keeps the boundary and the retained suffix and drops every
    assistant message above them; the usage those turns recorded was paid for
    when they were admitted, and a transcript re-costed after the swap no longer
    holds it. The manager now reports each replaced message that billed
    something, and every surface that costs the conversation from its messages
    adds it: a -p run's cost_usd and stream-json usage (which is what makes
    a resumed run count what the earlier one spent on a turn the summary
    removed), the ACP budget gate, and a beetle member's tally — which now also
    books the member's own summary requests, closing the gap the entry above
    described. A host that books every turn_end as it happens (the REPL, a
    subagent) is not given the new callback, so nothing is counted twice.

  • A multi-block result keeps every block's full text on disk. When one cut
    spilled more than one text block of the same result, each block was written
    to a file named from the call id, and the blocks share that id, so each
    write replaced the one before: every preview's pointer but the last named
    bytes it did not hold. The writer now suffixes -part-N, counted by
    occurrence among text blocks
    (image and other blocks do not count), and a single-block result keeps the
    name it always had. SpillRequest.part carries the number.

  • A subagent's or band member's cut output stays recoverable. Neither a
    subagent nor a beetle member has a session file to fall back on, and neither
    passed a spill writer, so a preview they produced named nothing and the full
    text was gone. Both now write through the tools' own spiller under the cwd
    their inherited tools were built for — the parent's root, not a workflow
    worktree that root's Read may not open — and the same writer serves the tool
    pipeline's own cuts. With no session id on either run, the files land under
    unassigned and age out with the rest.

  • BashOutput and KillBash say which ids exist. An unknown id answered
    Unknown shell id: X or not found or not running, which left the caller to
    re-read the transcript or guess. A miss now lists up to eight known ids with
    their state, and says how many earlier ones it left out. KillBash separates
    an id that never existed from a shell that already ended — naming its exit
    code, or saying it was already killed, and pointing at BashOutput — from a
    kill the OS did not confirm, where it asks for a poll instead of claiming the
    shell was not found. BashOutput also stops calling a finished shell's empty
    log (no output yet): a running shell says (no output yet), an ended one
    says (no output), and a log holding only the manager's own exit-code
    marker counts as empty because the status line already carries the code.

  • A search that could not see the whole tree says so. Glob's No files matched. read as a fact about the tree even though .gitignore and the
    built-in skip list had already filtered it. An empty answer now names the
    pattern and the root, says both filters ran, and points at **/ and at Read
    or LS for a path already known. Glob and Grep both report the walk's own
    file cap when they hit it, and Grep counts the files it skipped for size
    (over 1 MB) and for being binary, beside the unreadable files and directories
    it already named.

  • An escaped command is read as the shell runs it. The classifier read a
    command line as written, so a POSIX backslash left the program r\m and the
    target \/ — names no shell runs — and CMD's caret did the same to de^l /s /q and r^d /s /q. The tokenizer now applies POSIX's escape grammar and
    leaves a Windows backslash alone, where it separates path segments; the
    Windows rules read the caret-folded line as a second reading, with a quoted
    caret kept literal. rm -r also recognizes a Windows drive root, a profile
    directory, the installation directories, a UNC share root, and .GIT by the
    case-insensitive name a Windows filesystem gives it.

  • A deny or ask rule sees the command the shell would run. Quoting,
    backslash escapes and runs of whitespace were invisible to the matcher — git pu"sh" origin main did not match git push * — and a command substitution
    inside an allowed command inherited the allow. Deny and ask now match the line
    as written and normalized, and recurse into nested scripts; allow still has to
    match the whole line, and refuses a line whose substitution it cannot read.

  • A file rule reaches the shell's other readers and writers. A Read(...)
    deny covered the Read tool but not grep, rg, sed, awk, dd if=, mv
    or tar, which open the same path from Bash. Their path operands are now
    checked too.

  • A sign-in that cannot reach the session's model says so. /login chatgpt
    (or gemini, or the bare Claude form) on a session still on the default
    anthropic model printed the success line, and the next prompt still failed on
    a key that sign-in could never supply — a success followed by a failure reads
    as the sign-in not working. The command now adds one line naming the model
    still in force and the /model switch that reaches the signed-in wire. It
    does not switch by itself: a login should not change a setting nobody asked
    it to.

  • A screen taller than the terminal is clipped, not squeezed. When a
    dialog, the suggestion list or a long draft pushed the live screen past the
    window's height, the last box shrank and drew its rows from overlapping
    offsets — text overprinted itself and the prompt's border was drawn through
    the advice under it. The screen now keeps its height and the frame drops
    whole rows off the top.

  • The slash-command list reads as a table. Each suggestion was one wrapped
    sentence, so a long description ran to a second row and pushed the next
    command out of alignment. A suggestion is now one row: the name in a column
    of its own, the description aligned beside it and cut with … at the
    terminal's edge. Under about 60 columns the descriptions give way and the
    list is names alone.

  • The YOLO phrase field looks like a field. The confirmation dialog asked
    for the exact sentence but drew the typed text with no marker and no caret,
    so the row read as another line of the list and nothing said the keys had
    somewhere to go. It now carries the prompt's > and block caret.

Added

  • Shift+Enter inserts a newline in the prompt. The REPL negotiates the
    kitty keyboard protocol, which is what lets the terminal report the shift
    modifier; in legacy mode both keys arrive as a bare carriage return. A
    terminal without the protocol keeps working, but cannot send the key.
  • The thinking level is shown in the status line. /think now badges the
    level it set (think:high) beside the model name, in both the idle row and
    a running turn. An unset level shows nothing, because each model's own
    default is not a decision the session made; off is.
  • Every answer carries its cache share. When the provider reports cache
    activity for a turn, the answer is followed by the share served from cache,
    the prompt it was a share of, and the read/write split. A turn with no cache
    activity gets no line.
  • Linux commands run behind a syscall filter. Bubblewrap loads a cBPF
    program that refuses the io_uring entry points and AF_VSOCK sockets with
    ENOSYS and kills a mismatched ABI. The loopback bridge still works because
    AF_UNIX stays allowed.

Changed

  • Windows defaults to Windows PowerShell. Commands run through
    powershell.exe -Command with a wrapper that stops on cmdlet errors, forces
    UTF-8 output, and exits with $LASTEXITCODE. The search order is
    LBB_SHELL_PATH (with LBB_BASH_PATH kept as an alias), Windows PowerShell,
    pwsh.exe, Git Bash, a PATH bash, a Git install found through git.exe,
    and finally cmd.exe. Windows PowerShell is first because it lives in
    System32 and every container can execute it. The Bash tool's description and
    the system-prompt lines now describe the grammar of the shell in use.
  • Prompt caching reaches further. Every non-empty cache tier is marked on
    the Anthropic wire, since a mark below the provider's minimum is ignored
    without an error and the estimate has no upside. Tool definitions are sorted
    by name, so a server reconnecting in a new order no longer rewrites the
    prefix. /cache and the status line follow the current model's family after
    a switch or fallback. The idle compaction trim waits out a 24-hour cache
    retention instead of assuming the entry expired.

Fixed

  • Scrolling up no longer duplicates the transcript. A frame as tall as the
    terminal was treated as fullscreen by ink, which reprinted every sealed row;
    on ConPTY each such frame appended another copy to the scrollback. The frame
    is now capped one row below the viewport and anchored to the bottom, and
    opening and closing the Ctrl+O transcript no longer reprints the sealed rows.
    A permission dialog behind the transcript no longer answers keys.
  • Git Bash is found through git.exe. Git for Windows puts only its cmd
    directory on PATH, and the bash.exe scan missed the install one level over;
    every command then ran under cmd.exe. cmd.exe commands also keep their quotes
    now, through node's shell mode rather than an argv item escaped as \".

Internal

  • Test coverage is published from its own Ubuntu CI job: the reporter's table
    goes into the job summary and lcov is uploaded. It is not a gate.
  • The Windows fixtures read the runner's own paths: PowerShell's cwd is
    compared in the spelling it reports, and the AppContainer timeout test uses
    a cmd builtin sleeper that needs no child process, pipe, file, or socket.

0.1.0.1 (Alpha) — 2026-10-24

Adds RPM and AppImage packages for Linux and brings the Kimi K3.1 Pro model
into the direct, Go, and OpenRouter catalogs.

Release notes

0.1.0 (Alpha) — 2026-10-23

The first public alpha: a terminal coding agent with sandboxed tool
execution, provider migration, and offline binary inspection.

Release notes

Downloads

Platform Artifact
Windows x64 LaBunbun-Code-0.1.0.5-alpha1-x64-setup.exe
Linux x64 (Debian/Ubuntu) labunbun_0.1.0.5.alpha1_amd64.deb
Linux arm64 (Debian/Ubuntu) labunbun_0.1.0.5.alpha1_arm64.deb
Linux x64 (Fedora/RHEL) labunbun-0.1.0.5-alpha1.x86_64.rpm
Linux arm64 (Fedora/RHEL) labunbun-0.1.0.5-alpha1.aarch64.rpm
Linux x64 (AppImage) LaBunbun-Code-0.1.0.5-alpha1-x86_64.AppImage
Linux arm64 (AppImage) LaBunbun-Code-0.1.0.5-alpha1-aarch64.AppImage
macOS Apple Silicon labunbun-0.1.0.5-alpha1-darwin-arm64.zip
macOS Intel labunbun-0.1.0.5-alpha1-darwin-x64.zip

GitHub rewrites the ~ in the Debian version as . in download filenames. The
package inside declares Version: 0.1.0.5~alpha1.

Install

Upgrading from 0.1.0.4 uses the same commands; the product version moved, so
the package manager replaces the earlier release.

  • Windows: run the installer. It installs for the current user and can add
    labunbun to PATH.
  • Debian/Ubuntu: sudo apt install ./labunbun_0.1.0.5.alpha1_amd64.deb
  • Fedora/RHEL: sudo dnf install ./labunbun-0.1.0.5-alpha1.x86_64.rpm
  • AppImage: chmod +x LaBunbun-Code-0.1.0.5-alpha1-x86_64.AppImage && ./LaBunbun-Code-0.1.0.5-alpha1-x86_64.AppImage
  • macOS: unzip, move labunbun wherever you like, then clear the quarantine
    flag: xattr -d com.apple.quarantine labunbun

The macOS and Windows builds are unsigned, so Gatekeeper and SmartScreen will
warn. The macOS archives carry the execute bit on the binary.

Checksums (SHA-256)

48803992734b9447de320dcc08200e4138d64f6f39a16ff3b3ef79ddc0e98fe9  LaBunbun-Code-0.1.0.5-alpha1-aarch64.AppImage
e547f2f9d05ee3692c7d49ea672051a8820fe3fa2199da8199a978095c7ff17c  LaBunbun-Code-0.1.0.5-alpha1-x64-setup.exe
161aae4c37d36461c7d472b7e36ecfe7a0c281fc6dcbd56f08ede524ac4f07c6  LaBunbun-Code-0.1.0.5-alpha1-x86_64.AppImage
951dd9192caa7d308695fe6d20f45873374c4636cbff3166ea30217d2d3f6217  labunbun-0.1.0.5-alpha1-darwin-arm64.zip
8401de5d9dc91d418db3d9a978c1e9a40f364c27fc1c014921a482c3563f6937  labunbun-0.1.0.5-alpha1-darwin-x64.zip
9081a013108d0fe25669d1e0f1bdaa7d39cc99c101d590aa7519501425a809e5  labunbun-0.1.0.5-alpha1.aarch64.rpm
ed845eb41675ac99dc19aae5fb356198b83f6fc2cf66b9c36b819ddf158ac2c3  labunbun-0.1.0.5-alpha1.x86_64.rpm
0689098dae0484269f8a5b90b5d884322d899974d0509852f97e43b43a3f6359  labunbun_0.1.0.5~alpha1_amd64.deb
a2cab9d4510e5c2d42c865a8437f7238b3e6f3442bea15fd9f139c91ccbd8b7b  labunbun_0.1.0.5~alpha1_arm64.deb