Skip to content

v0.14.0

Choose a tag to compare

@github-actions github-actions released this 05 Oct 23:58
· 5639 commits to main since this release
2d4d72b

Highlights

  • Tab completions with a separate hard daily budget. Invoke ghost text with Alt+; first-use consent names the price and $1.00/day default.
  • Git and pull requests from the panel. Draft, commit and push with confirmation, then create or open a GitHub PR in a held conversation worktree.
  • Hooks and plugins from other agents. Import popular hook formats, run Setup and Manual hooks, and use bounded Amp and OpenCode plugins on the Model API backend.
  • Preview a scrubbed problem report. Review, copy or save the exact local report before choosing to open an issue; the extension sends nothing.
  • Muse Judge phase 1. The conversation model can add uncalibrated caution to an approval without granting permission. Model API use asks first and shares the durable daily budget.

Added

  • A quiet GitHub star link in the GitHub and Marketplace/Open VSX READMEs,
    What's New footer and Getting Started welcome step, with the footer and
    step description translated in all 14 languages.

  • Tab completions (M94, PLAN.md D73). On by default, with its status
    item visible at startup and its completion engine loaded on first use.
    Alt+\ invokes ghost text; the five Tab commands turn it on/off, snooze it,
    open its menu and choose languages. The default trigger is Invoke because
    the probe measured 3.8 s median to first text. The first charge asks once
    per window, names the model's rates and the $1.00/day default hard budget;
    the stored Model API key pays on either chat backend, never the subscription.

    • Fast and multi-line context, filtered completions, typing-through cache,
      bounded scheduling and per-window daily-ledger files shared across all
      windows. Reported usage settles reservations; missing usage retains them.
    • Related recent-edit and definition snippets now reach the engine in
      path order, within the context limit, through the same file privacy
      checks as the current file; secrets are redacted before cutting excerpts.
    • The status item shows spend, snooze, budget, no key, trust, language and
      Copilot states. Account & usage counts Tab requests, tokens, cached tokens,
      this window's reported cost and the cross-window day/budget.
    • Translated commands and multi-line picker labels in all 14 languages.
      dist/tab.js ships in the VSIX, with size, module-split, model-text and
      host-global checks; the host-API record is regenerated.
    • Cursor's Tab hook bridge is prepared; executing those hook configurations
      and the final live check wait for M91/lane K.
  • Git and pull requests from the panel (M71): editable commit and PR drafts
    written by the user's Muse turn, explicit commit/push consent, GitHub PR
    creation and conversation-linked checks. Push never uses force. A commit's
    consent covers the bytes of new files too, in either of VS Code's views of
    them, so a commit whose new files changed after the consent is refused. A
    foreign PR opens in its own held worktree, with project configuration and shell
    access off until the extension's trust card is confirmed. Git never checks
    a foreign PR out: the worktree is added with --no-checkout, its index
    read from the commit, and its files written by the extension exactly as
    stored, so no filter, hook or conversion runs wherever Git's configuration
    defines one. Paths that would leave the worktree, name .git, use a name
    the platform cannot hold or collide where case does not count refuse the
    checkout whole, as do PRs over 20,000 entries or 250 MB. A trusted parent
    record never releases a held PR below it. Best-of-N, the session board's
    worktree reads and /review of Git's changes run no Git in a held PR
    window until its trust card is confirmed, whatever VS Code's trust says.
    Concurrent opens of the same
    held PR preserve the successful checkout's record when another open
    fails. The held checkout rejects non-commit SHA arguments before Git
    runs and reports an overflowing tree listing as the existing too-large
    refusal. Physical-owner and lifetime
    guards refuse stale operations. Commit, push, PR fetch and checkout use
    checkpoint process admission.

  • Hooks and plugins (M91/M91b, PLAN.md D70). Trusted, opt-in
    spark-hooks.json dispatch reaches extension events on both backends,
    with Setup and Manual commands, /hook run, bounded file/settings
    notifications and MessageDisplay markers. Muse Code never reads that file.
    The standalone agent can run trusted Setup without a model call.

    • Importers cover Codex, Gemini, Cursor, Copilot and VS Code, Windsurf,
      Kiro and Cline. Codex native hooks run on both backends; foreign-format
      adapters and Amp/OpenCode plugins run on the Model API backend. Unsupported
      or weaker event mappings are refused visibly. No foreign answer grants.
    • Typed http, mcp_tool, prompt and agent handlers keep their trust,
      network, permission and paid-consent boundaries. Model hooks use the shared
      daily ledger; bounded hidden agents can only read, search and use read-only
      code intelligence. Their usage appears separately.
    • Model API shell calls keep a confined current directory; then_run and
      checks stay at the workspace root. modelApiShellKeepsDirectory can disable it.
    • MCP forms validate the supported flat schema subset, ask even in Bypass,
      and cancel on Stop, timeout or closing. Elicitation hooks run through the
      wired host seam; answers never enter logs or saved transcripts.
    • Plugin children have bounded lifetimes, memory and credential-free
      environments. OpenCode is refused on macOS and plugins are refused in ACP.
      Windows offers Retry Plugin Hooks after containment preparation failures.
    • Hook runtimes, imported adapters and plugins each load on first use.
      Hooks-off golden Model API bodies remain byte-identical. The certification
      records retain capture qualifications and unsupported events.
  • Report a problem (M93, PLAN.md D72). Muse Spark: Report a Problem,
    the palette's Support item, "Report this" on recorded error rows and
    notices, and the crash screen open one dialog that builds a scrubbed report
    locally. No chat, sign-in, backend, model call or network request is needed,
    and nothing is sent by the extension.

    • A flight recorder, not a log. Each window keeps a bounded journal of
      facts under VS Code's global storage (7 days, 256 KiB a journal, pruned
      at start, append and read): a fixed event kind, a known error class or
      the word unknown, the versions, and stack frames inside the shipped
      bundles only. No prompt, code, file content, model output, tool text,
      message, path, id or credential is ever written. Links and unexpected
      files are refused.
    • The exact draft first. The dialog shows the final scrubbed text,
      lists every item in it (each removable), takes an optional description
      and warns that it can still disclose something. Copy, Save, the
      prefilled GitHub new-issue page (copy plus the empty form past 2,000
      encoded characters) and, where VS Code has it, its own issue reporter
      all export that same sealed text; a change after the preview re-previews
      instead.
    • After a crash, the next activation offers once: "Muse Spark Code
      stopped unexpectedly last time — report it?" A second live window is
      never taken for a crash.
    • Headless. muse-spark-code-acp report prints the same scrubbed
      report from the agent's own journal, starting nothing; in ACP mode the
      agent records its own failures there without touching ACP stdout.
    • Windows reports. UNC and extended Windows paths are scrubbed,
      including quoted paths with spaces. Workspace/home replacements accept
      equivalent Windows case and separators; extended paths retain verified
      package stack frames. Windows link, open-file pruning and CRLF export
      checks are recorded in docs/certification/m93.md. The dialog's section
      switches now have enough room for Windows native checkbox targets.
  • Muse Judge phase 1 integration (M98, PLAN.md D77). Same-model,
    uncalibrated risk advice at existing reviewer and card fences, a fixed
    caution note, status and separate usage rows. Muse Code uses fresh hidden
    Plan sessions on the subscription, with standing-rule checks, redaction,
    cancellation and temporary-folder cleanup. museSpark.judge.engine
    selects auto (default), same or off; the Judge bundle loads only at
    an eligible approval. Model API main-body goldens and main-session MSP
    invariants remain unchanged. Paid transport admission, credential-wait
    rechecks and unknown-cost liability are integrated, but Model API Judge
    uses D78’s shared durable daily ledger, reserving once before dispatch and
    retaining uncertain liability. Subscription-only users see no Judge price popup.
    Local/separate Judge, CLI, live measurements and full certification remain
    planned.

Changed

  • After all four release channels publish successfully, a credential-free final
    job waits for public version propagation, refreshes README badge URLs and
    purges GitHub's camo image copies. Older version badges get a cache-busting
    retry and an original-URL recheck; stale caches and network failures warn
    without failing the release.

  • Preserve both full What’s New releases in a bounded lossless artifact
    envelope, keeping its existing 40-KiB file cap and plain-file compatibility.

  • Share existing Node boundary schemas in one validated runtime and losslessly
    encode the complete inline browser English fallback, retaining every key,
    value and plural form within the unchanged bundle and archive caps.

  • Load Report only when opened, preserving loading cancellation and
    opener focus. Keep Share and Session Board eager within the unchanged combined browser caps. Keep the browser’s review-comment template separate from
    backend instructions and emit equivalent UTF-8 browser text.

  • ACP loads the same recorder bundle before report reading or session startup,
    keeping the journal implementation out of its entry bundle.

  • Keep English fallback regions lazy through descriptor-preserving locale
    state. Runtime, hooks and optional surfaces load their text on access;
    browser and integration builds retain their inline fallback.

  • Load the conversation implementation on the first chat surface, install its
    caller's display language, and keep backend restart handling eager. Move
    conversation-only model prompts beside their lazy readers.

  • Package translated UI values in one bounded lossless archive; installed
    values stay identical, while source and ACP tables keep their JSON format.

  • M100's paired-device plan now states connectivity prerequisites. Manual
    address entry bypasses discovery only; routing and explicitly authorized
    inbound access are still required. D80, acceptance B/K and the research
    record specify blocked/unreachable setup recovery, standard-user/default-
    firewall and explicit-deny cases, and per-rig listener/permission evidence.
    Devices and mDNS stay off by default as an explicit security exception to
    enhancements-on. Documentation only; no pairing or remote execution ships.

  • Keep paid HTTP clients in the existing Model API bundle until first use; compress production Node English text and packaged UI tables without changing their decoded values or size budgets.

  • Plugin limits (M91b).

    • OpenCode plugins are refused on macOS, where bun's memory cannot be
      bounded.
    • Plugin hooks are refused in the ACP agent.
    • An OpenCode tool.execute.before blocks the call when it throws,
      crashes or times out. Every other plugin hook fails open.
  • M50's Windows MCP job launcher takes an optional job memory limit.
    MCP servers still start without one.

  • M98 integration repairs. A ready Judge latch is invalidated when its
    live source becomes unavailable; the main Model API body is read from the
    actual sent request. Hidden-session rows stay out of History, and the
    PowerShell tool toggle fits within a 320 px panel. Invalid side-receipt
    counts fail before they reach usage rows. Hosted-tool prefixes use
    standalone Judge bodies, so token consent grants no hosted-search charge. Every existing
    bundle and VSIX cap is preserved; the new lazy Judge has a 100 KiB cap
    from its 77.7 KiB measurement plus the existing sizing rule.

  • Accessibility browser driver. All scenarios use the existing
    Playwright page driver after Chrome's --dump-dom stalled on ordinary
    pages. The scenarios, themes, page timeout and axe finding rules stay
    unchanged.

  • Tiered CI, ready for a merge queue. The full gate now runs as parallel
    jobs:

    • the static gates on all three platforms;
    • the unit/e2e tests in four coverage shards per platform, merged before
      the unchanged thresholds apply;
    • the accessibility harness once, on Ubuntu;
    • integration on Ubuntu and Windows;
    • the macOS helper and the universal packages.

    A merge_group run checks the commit that will land. Once the maintainer
    turns on the queue and sets CI_MERGE_QUEUE=on, pull requests run only a
    fast Ubuntu tier: the static gates, the build, every test, gitleaks and
    semgrep. Until then every pull request keeps the full tier. The seven
    required check names and the release artifacts are unchanged. In a merge
    group, gitleaks runs its pinned, checksum-checked CLI, because the gitleaks
    action refuses that event.

  • The extension loads less at startup: dist/extension.js is
    436.7 KiB after the integrated startup repair, under its unchanged 600 KiB budget
    (PLAN.md D6, 2026-10-03 and 2026-10-04). Model text that only a lazily
    loaded bundle or the ACP agent reads is no longer carried at activation
    (same words, in blocks by reader), and the window's web fetch loads with
    its own bundle, dist/webFetch.js (budget 75 KiB), on the first fetch; if
    it cannot load, that fetch fails with the reason ("Web fetch could not be
    loaded", in all 14 languages) and the next one tries again. The lazily
    loaded bundles shrink too (the Model API backend, the checkpoint store,
    the import, code intelligence and both reviewers by 4 to 27 KiB each).
    npm run build now fails when a shipped bundle carries a model-text
    block it does not read, or when MODEL_TEXT holds a key no source file
    of dist/extension.js reads; the code intelligence and web fetch
    bundles' tests check that neither carries any key or value of MODEL_TEXT.

  • Releases reuse verified universal CI packages when the successful own-repository
    PR, merge-queue or main CI build has exactly the tag's source tree, with recorded
    SHA-256/version checks and 30-day retention; tag-push misses run the full gates.

  • Manual release recovery uses the same verified staging path while preserving
    the earlier run's original bytes; invalid recovery and cancelled runs cannot publish.

Fixed

  • Extension hooks use the held-project trust check before loading or running, including Setup and Manual hooks.

  • Register every newly merged and split bundle in the report’s exact frame
    vocabulary so its package-only stack frames remain available after the diet.

  • Muse Judge (M98, RVM98J). Boolean action arguments hash correctly;
    retried actions reject stale callbacks and fences; complete prompt batches
    fit the measured context; choice and score tokens must be one character.
    Explicit same honors the user's selection below the automatic readiness
    floor, logprob metadata matches the shared contract, and top-1 estimates
    correctly report partial evidence. Startup excludes the judge from legacy
    paid price review and loads no judge schema. The first-charge wording in
    every language says ask once and shows the shared daily budget. First-use consent and D78 accounting are wired through the window factory;
    remaining live and isolation qualifications stay explicit in its certification.

  • CI reliability: the checkpoint-copy count test crosses a small test-only
    budget with six real copies, then checks the exact read bound and reuse of
    the same directory cursor. It avoids hundreds of unnecessary disk operations
    and no longer accepts repeated traversal restarts as eventual success.

  • The README's "What's new" section matches the release again. 0.12.1 and
    0.13.0 shipped with the README still headed "What's new in 0.12.0". The train now
    describes 0.14.0, the Marketplace README carries the same section, and a
    test fails any release whose README section does not name its version.

  • M91's Gemini hook adapters translate established native arguments
    and explicitly refuse unsupported blocking calls. Tool-selection whitelists
    survive ANY without forcing a call. Captured nested arguments and saved
    vendor scripts now have data-dependent checks; certification claims are
    limited to the evidence actually checked. Model packets validate their
    captured shapes, tool patches preserve full original arguments, ignored
    lifecycle controls retain observations, and Notification retains details.

  • M91 import review, round 3: unreadable source switches refuse hooks;
    Copilot inline settings refuse siblings together; Cline script references
    are checked again after awaits and during planning, quoted as literal paths
    for Unix and PowerShell, and retain their 30-second bound. Nonexact tool
    matchers and Gemini lifecycle filters refuse visibly, Gemini sequential
    policy spans user and project settings, Cursor requires version 1 and
    uses the adapter's source-event contract, and universal Copilot regexes
    remain supported. Truncated or normalized MCP identities are refused.
    Kiro Manual is refused until its adapter has a row.

  • Restore dead-export checks for shared constants: the exec schema tests use named imports instead of enumerating the whole module, and Knip also checks unused namespace values and types.

  • Deferred-bundle split drills now build the checked Node entries once in
    memory and call the production guard directly. They retain rejection and
    byte-exact restoration checks without repeated full-repository scans,
    child processes, shared dist/ mutations or longer timeouts.

  • A blocked M80 v0 tag update now reports that an administrator must move it,
    while preserving the four release channels' outcomes. Updates require a
    fast-forward; the release guide documents the administrator's recovery command.

Security

  • Tab uses held-project trust for completions and rechecks it at the native Git entry for ignore lookups, so a held pull-request worktree runs no automatic Tab Git command.

  • The plugin child (RVM91X review, M91):

    • Contained. On Windows it runs in a kill-on-close job, so it cannot
      leave descendants behind. It sees only the allowlisted hook
      environment, as does the version probe.
    • Memory-bounded. The limit is 1 GiB: a Windows job limit, a node
      heap cap, or prlimit for bun on Linux.
    • Validated. Every answer it sends is parsed by a closed schema, and
      no plugin answer grants a permission.
    • Ruled. A failed answer follows the call's fail-closed rule, and an
      earlier refusal survives a later handler's failure.