Skip to content

Releases

Fuigo 1.0.45

Choose a tag to compare

@github-actions github-actions released this 16 Nov 04:05
30f2eb8

Fuigo 1.0.45 release notes

Folder trust and consent

  • A nested repository no longer borrows its parent's trust. A folder whose own git metadata points at a trusted
    ancestor (through core.worktree) is asked about like any other folder instead of being treated as trusted with no
    question. The same holds for the folder a session works in when a core.worktree ancestor has no .git.
  • Task children are judged in the folder they were launched from. A subagent started with a cwd is checked
    against its parent's launch folder as well, so it cannot move a session from an untrusted folder under a trusted
    folder's shell rules. A relative cwd is resolved against the parent's cwd, not the process's.
  • No git status scans in untrusted folders. The in-process change tracker waits for the folder-trust decision, so a
    repository-configured content filter cannot run before you have answered.
  • No language servers in untrusted folders. User- and plugin-configured language servers start only after the
    folder is trusted.

MCP servers and plugins

  • Untrusted folders cannot start MCP servers under a different name. A project server whose name needed
    sanitising, or that was forwarded under a renamed copy, is now dropped in an untrusted folder like any other project
    server.
  • Project plugin settings in an untrusted folder cannot touch your plugins. A project's [plugins].disabled no
    longer switches off your own plugins, and a project plugin with the same name no longer displaces yours.
  • Marketplace plugins do not refresh themselves at startup. The spawn-time local refresh skips installs that came
    from the marketplace cache, so a plugin changes only through an update command.
  • Bounded tools/list pagination. A server that returns endless pages, endless tools or a repeating cursor stops
    at a fixed cap instead of looping.

Sandbox

  • Custom sandbox profiles work in the workspace server. The workspace server resolves your custom profiles the
    same way the main binary does instead of replacing them with workspace and possibly continuing unsandboxed.
  • A bad [sandbox] field is reported. sandbox.profile is read on its own, and a type error in another
    [sandbox] field prints a message on stderr instead of silently turning the sandbox off.
  • Project profiles in untrusted folders are ignored, and built-in names ignore letter case. A project
    sandbox.toml in an untrusted folder cannot select the profile, and Minimal or STRICT are treated as the
    built-in names.
  • The workspace .mcp.json and imported MCP config files are protected from sandboxed writes under enforce.
  • Missing protected entries are denied in every letter case on macOS, not only the spelling you wrote.

Editing and files

  • Edit tools never follow a look-alike filename. A file name that only resembles an existing one (for example with
    look-alike Unicode characters) is no longer silently redirected onto a symlink or another file.
  • Non-UTF-8 files are no longer corrupted. apply_patch and the other edit tools refuse to
    rewrite a non-UTF-8 file. Deleting such a file still works, reported without a snapshot.
  • apply_patch is safer with moves and adds. A Move onto the same file updates it in place instead of deleting
    it, and Add and Move report the destination's prior state.
  • Rewind restores the right content. write and search_replace report the true prior state of the file, so a
    rewind brings back what was there.
  • PPTX reads are bounded. Extraction has a total decompressed-size budget and a slide cap.

web_fetch

  • Hostile pages no longer hang or crash a fetch. Converting a page to text is bounded in time and memory: deeply
    nested markup, huge attribute counts, quadratic inline merges, long runs of newlines and nested tables are handled
    within fixed limits, and a page that would cost too much falls back to plain text.
  • Tables render without padding, with correct headers. Header rows come from the table head, cells are
    normalised, and captions are not pipe-escaped.

Sign-in and sharing

  • A huge expires_in or interval no longer aborts. A token response with an oversized value no longer stops
    sign-in or refresh.
  • Logout reports a real error. When the stored login cannot be read, fuigo logout says so and keeps the file
    instead of reporting that there was nothing to log out of.
  • Saved API key helpers follow FUIGO_AUTH_PATH.
  • Shared sessions are scrubbed before upload. The session body sent to the share backend gets the same secret
    scrub as the copy kept in storage.

Terminal, links and media

  • File links reveal launcher-type and executable files instead of opening them, so a modifier-click on a path in
    repository content cannot run it.
  • Network-share paths are not probed. Paths found in model or tool text are never stat'ed or read when they name a
    network share.
  • Image reads are capped. Inline images over the size cap are skipped and remembered as too large, and ffmpeg,
    ffprobe and sips calls have time limits.
  • fuigo wrap: one host-image read at a time, at most one per interval, with a bounded write queue.
  • Image paste through fuigo wrap over SSH: a new local fuigo wrap now authenticates image-paste requests with a
    per-session nonce, so pasting an image into an older fuigo on the remote side no longer works until that remote is
    updated. Commands Fuigo runs no longer inherit the nonce.
  • Permission cards opened while you type hold the next Enter and digit, so a keystroke meant for the composer does
    not answer the card.

Release, update and serving

  • agent serve warns on a non-loopback address. Binding beyond loopback over plain ws:// prints a loud warning.
  • Updater temp file is private. The temporary .npmrc is created exclusively, mode 0600, in an owner-only
    directory.
  • Install scan skips empty and relative PATH entries, so fuigo --version is not run from the current folder.
  • Release workflow is stricter. A real publish is refused off a tag or without macOS signing, and the in-tree
    leftover upstream install scripts, which downloaded from hosts Fuigo does not control, are removed with their README
    line.

Campaigns

  • Campaign patches cannot move trusted API origins. The session bearer and FUIGO_API_KEY stay with the origins
    you configured.

  • Campaign patches cannot set where a model connects or what it sends. Hosts, headers, query parameters, providers
    and keys of every model stay the ones you configured.

  • Campaign-added MCP servers are untrusted and carry no secrets: no saved-key references, and no environment,
    header or OAuth secret fields.

  • Stored MCP tokens survive a damaged or unreadable mcp_credentials.json. A file that cannot be read is left
    alone and the save fails; a damaged one is copied aside first. Every write, including removing a server, is locked
    on every platform.

  • Campaign patches cannot set execution policy or where data and code come from. [sandbox], web fetch local
    access and proxy, the shell environment policy and command prefix, the hub, telemetry destinations and exporters,
    web search routing, session trace upload and the telemetry switch it follows, the agent definition and agent
    name, which plugins are enabled, whether language servers start, which MCP servers you disabled, subagent role
    and persona files, and the sources of updates, plugins, skills and rules stay as you configured them. Campaign
    values are never expanded from environment variables. Administrators set these in their own managed or
    requirements layer, not inside a campaign.

  • Campaigns can now set only what campaign features use. A campaign can set the default model and the helper
    models (a nudge your own /model pick always overrides), a model's display name and context window, add new
    MCP servers (without secrets), and turn managed MCP servers off. Everything else in a campaign is ignored, and
    Fuigo shows a note naming the settings it ignored.

  • Campaign model nudges cannot reach your own endpoints or keys. A campaign may name a catalog model or one with
    no route of its own, not only a built-in one. It cannot point the default, image-description or
    session-summary model at a model whose endpoint, provider or credential your own configuration sets; such a setting
    is ignored with a note. A context window outside 1,024 to 10,000,000 is ignored, and a change to a helper model is
    announced once.

  • A program-running MCP server added by a campaign waits for you. It is listed as off until you turn it on in
    /mcp or with fuigo mcp enable <name>, and if the campaign later changes its program, arguments, folder or the setup choice that picks the program, it needs
    your approval again. This wait covers program-running (stdio) servers only: a campaign HTTP server does not wait
    for approval, and your own servers are unchanged.

  • Campaign notices are cleaned and capped, name only the sub-settings that were ignored, and show the program a
    campaign MCP server would run.

More fixes

Shell and tools

  • When a model sends several JSON objects in one tool call, Fuigo runs the one that fits the tool.
  • Output a command prints after it exits or is stopped no longer grows memory or the log file without limit; the
    short drain after a background task exits keeps at most 8 MiB.
  • Two shell calls that share one call id no longer share a log file or overwrite each other's background task.
  • In the persistent shell, programs a command starts (bash 4+ and zsh) can no longer write to the channel Fuigo uses
    to save shell state. Two limits remain by design: builtins running in the same shell can still write to it, and
    bash 3.2 (the stock macOS /bin/bash) hands the saved copy of the channel to the programs it s...
Read more

Fuigo 1.0.44

Choose a tag to compare

@github-actions github-actions released this 14 Nov 05:59
991e998

Fuigo 1.0.44 release notes

Sandbox: a read-only launch folder

  • New built-in minimal profile. fuigo --sandbox minimal runs with the strict profile's reads and network
    policy, keeps session state, temp files and devices writable, and makes the folder Fuigo was launched in read-only.
    Use it for a checkout you do not trust.
  • New workspace_write setting. Any custom profile can set workspace_write = false to make the launch folder
    read-only. Leaving it out keeps the base profile's behaviour, so existing profiles are unchanged. The read-only
    launch folder wins over any write grant inside it, including relative paths, which are never created there.
  • Enforced, or Fuigo does not start. On Linux a read-only launch folder needs bwrap: if bwrap cannot run, Fuigo
    and the workspace server refuse to start with a clear message instead of falling back to a weaker sandbox. A Linux
    build without sandbox enforcement refuses minimal the same way. macOS uses Seatbelt. Windows warns and continues.
  • No new aliases. The sandboxed process cannot create a hard link to a launch-folder file in a writable
    directory, on the same filesystem or another one, or move a launch-folder file out.
  • Profile names you did not write cannot weaken it. A project's own .fuigo/sandbox.toml cannot redefine a
    built-in name (minimal, workspace, devbox, read-only, strict, off): the built-in applies and a warning
    names the file. Your own ~/.fuigo/sandbox.toml can still define [profiles.minimal], which keeps working as before
    and prints a warning that it shadows the built-in.
  • Warnings instead of silent surprises. Unknown keys inside [profiles.*] and session storage that would sit inside
    a read-only launch folder each print one warning; Fuigo keeps starting.
  • Deny entries written with ./ now work on macOS. A deny = ["./.env"] entry (or any path containing /./)
    was not enforced on macOS, so the file stayed readable. It is now denied like .env. Linux was not affected.
  • ~ in a deny entry means your home everywhere. deny = ["~/.aws"] already protected the home path for
    sandboxed commands; Fuigo's own process now applies it to the home path too, instead of a ~ folder inside the
    workspace.
  • Known limit. Like any path-based sandbox, it cannot see links that already exist before launch: a hard link or a
    writable bind mount of a launch-folder file created outside the sandbox keeps that path's own access.

Folder trust and consent

  • No answer before the question is on screen. A follow-up click after accepting the consent notice or trusting a
    folder no longer acts on the next screen before it is drawn, and keys typed before the trust question appears are
    ignored. "On screen" means the terminal has finished writing the frame that shows the question. Ctrl+C and Ctrl+D
    always work.
  • Short terminals. The trust question accepts answers whenever its line is visible, even when the menu has no room.
  • Tiny terminals. Welcome, consent and trust screens and MCP elicitation cards draw without crashing or overflowing
    at any size down to 1x1.

Sign-in

  • Sign-in finishes against the login stored now. If another window logs out, signs in again or switches account
    while a browser or device-code sign-in is open, completing it writes nothing and says the login changed in another
    window. Token refreshes and account details loading during the sign-in do not count as a change.
  • Logout is reliable. A logout that cannot remove the stored login reports an error and keeps the session instead
    of reporting success. Logout no longer freezes the screen while it waits for another window.
  • An unreadable auth.json does not block sign-in. If the file cannot be read (for example a permission error), the
    new login works for this session only and is not saved, with a warning; that session leaves auth.json alone
    until Fuigo restarts, so an older stored login cannot take its place. A corrupt file is backed up and replaced, as
    before. If the auth file stays locked by another window, sign-in stops instead of keeping an unchecked login.
  • Token refreshes never overwrite another window's login. A refresh that finishes after another window logged out,
    signed in again or switched account keeps its token in memory and leaves the stored login alone. This also covers
    the workspace server's refresh.
  • Sign-in screen starts fresh after logout or a cancelled login.
  • One retry in rare cases. With a 1.0.43 window open, or when a failed token refresh removes the stored login while
    a sign-in is open, that sign-in can report a change once; signing in again works.

Startup, paste and headless

  • Faster startup when the Linux system bus is slow. The power listener connects in the background; startup no longer
    waits for it. If it cannot connect within its deadline, power events are reported unavailable with one warning.
  • Faster startup when the terminal never answers the keyboard query. The probe has one 200 ms deadline, then falls
    back to classic key handling.
  • Large pastes without bracketed paste no longer stall. A 200 KB paste reaches the prompt in under a second instead
    of more than ten. A burst of 256 or more single-line key events arriving within 1 ms of each other is treated as one
    paste; a trailing Enter stays a key.
  • fuigo -p --resume needs an id or title. An empty or missing value is refused up front; --continue resumes the
    most recent session.

Display and input

  • Narrow and wide terminals: the usage modal, dashboard (compact rows at 40-43 columns), dashboard peek, plan review
    buttons, pickers, list panes, numbered lists past 10, terminal titles and CLI tables fit by display width, including
    CJK and emoji, and use one ellipsis style.
  • Failed web fetches show the real error when expanded; grep results expand tabs; open folds point down; empty pickers
    say what is empty.
  • Copying a table keeps inline-code backticks; Shift+drag beside the scrollbar copies no scrollbar glyph (also with
    NO_COLOR); drag selection scrolls straight away at the pane edge; Up on the first line of a question's text answer
    returns to the options unless a dropdown is open.
  • Legacy Windows consoles get plain fallbacks for the pending todo glyph and scrollback glyphs.
  • The composer draft is kept when a queued row being edited disappears under an open question; labels say "1 hook",
    "1 page" and so on.

Fuigo 1.0.43

Choose a tag to compare

@github-actions github-actions released this 12 Nov 05:48
48d6f8e

Fuigo 1.0.43 release notes

Rate limits and provider errors

  • Provider errors keep their code. In agent mode, a failed request's JSON-RPC error and every retry notice now carry
    a typed data.upstream object. It holds the HTTP status, the provider's error type and state, the Flux code
    and codes, hold_reason, limit, retry_after_s and resets_at. Before, only the message text survived, cut to
    280 characters. Existing fields keep their meaning. The agent-mode guide documents data.upstream as a stable wire
    format.
  • Only known values are reported. type, state and code carry values from a fixed vocabulary: Flux codes,
    supported provider error types and LiteLLM exception names. Anything else is reported as "other", so a value a
    provider echoes back, such as a key, never reaches the wire or a saved session.
  • Errors rewrapped by a gateway keep their code. A provider error quoted inside another error's message, for
    example by LiteLLM, is read for its code and reset time, including on a rejected sign-in and on errors that arrive
    mid-stream.
  • A Flux refusal that retrying cannot fix ends the prompt. A revoked or unknown key, a used-up allowance, budget or
    plan cap, or a Flux rate limit with no known wait now stops the turn with its reason instead of retrying in a loop. A
    rate limit with a known wait still backs off. Other providers keep their existing rate-limit retries, including
    Retry-After.
  • One sign-in refresh, then stop. A bare 401 on a session that can refresh its token refreshes once and resends
    once. A second refusal ends the prompt. A new prompt starts fresh.
  • A failed session-summary call no longer ends the main prompt.

Fuigo 1.0.42

Choose a tag to compare

@github-actions github-actions released this 10 Nov 22:09
c1605c3

Fuigo 1.0.42 release notes

Editing the prompt

  • Vim editing in the prompt. /vim-mode all (or [keys] vim = "all") gives the prompt NORMAL and INSERT modes,
    with motions, operators, counts, undo and redo. Enter still submits from either mode. The shortcuts sheet lists the
    NORMAL-mode keys while it is on. In NORMAL mode Ctrl+R is redo, so open the sessions list from INSERT mode. The
    /settings switch "Disable vim input mode" ([ui] simple_mode) now turns this same prompt vim on and off.
  • More ways to mention a file with @. @~/ reaches files in your home folder, @! reaches hidden files, and a
    :N suffix points at one line. The picker also lists files outside the workspace
    (ui.at_picker_outside_workspace, on by default). Typing at the end of a file chip edits it in place.
  • Quit with one Ctrl+C. With ui.single_ctrl_c_quit on, one press quits when nothing would be lost: no turn
    running, no draft, no queued prompt and no open question. Off by default.
  • /doctor warns about a slow tmux escape time. Inside tmux, an escape-time above 50 ms is reported with the
    command that fixes it.

Transcript

  • Dragging selects text across blocks. A drag that starts on text now runs on into the next blocks, and copy gives
    plain text without colours, borders or buttons. A drag that starts outside text still selects whole blocks.
  • Copy buttons work while a menu is open, and while a queued prompt is being edited.
  • Text stays readable in an 8-colour tmux session. Bright colours fold onto the eight normal ones there.
  • Markdown links that contain $ or LaTeX characters render as links instead of switching into math. A $ inside
    a link's address is shown as %24, which is the same address.
  • Mermaid diagrams break lines on \n and <br> instead of printing them.
  • Warp opens the whole of a wrapped URL.

Keys and input

  • Ctrl+E in minimal mode moves to the end of the line while you are editing a draft.
  • Ctrl+Y on a question card no longer closes it unanswered.
  • Esc on an unanswered /btw cancels it, and /btw starts a side question only at the start of a message.
  • A slash menu closed with Esc stays closed when the command list refreshes.
  • Typing while the transcript has focus goes to the prompt, including non-ASCII text, and leaves an open card alone.
  • Windows: Shift-held symbols and AZERTY digits work in shortcuts.
  • Double-clicking a view's close button no longer presses what was underneath it, such as a stop button.
  • Long pastes delivered as keystrokes no longer freeze while the plan-mode tip is shown.

Background work and the dashboard

  • Dock stop buttons work while that run's approval card is open.
  • Dashboard rows stay Working while background subagents and workflows run, and stopping a row ends them.
  • The footer's context use is right after a rewind.

Sessions

  • Delete, rename and copy refusals show their full text, and session load errors give the whole reason.
  • A deleted or renamed session no longer appears in resume lists or title searches.
  • A session with an unknown reasoning effort resumes with the default effort.
  • --resume <id> reads only that session, so it starts faster with many sessions.
  • A resumed session shows a background command's real run time in the turn that ran it.
  • fuigo export is faster and uses less memory on sessions with large shell output.

Hooks

  • Opt-in fail-closed hooks. A PreToolUse or UserPromptSubmit hook entry can set "failClosed": true. If that
    hook times out, crashes, fails to start, exits non-zero without a decision, or prints output that is cut off,
    unreadable or carries a key Fuigo does not recognise, the tool call is denied or the prompt is blocked. Hooks without
    the flag still fail open, as before. A prompt block applies only to a prompt you typed, as for any block.
  • A ! shell line now honours a hook's stop ("continue": false), as tool calls already did.

Updates and startup

  • Automatic update stops retrying a version that fails to start. Only a real launch failure counts: a slow first
    run or a busy file does not.
  • fuigo update runs when a sandbox profile is set, unless Fuigo is already confined. A confined session never
    auto-updates and tells you to run fuigo update instead.
  • --restore-code is safer. A failure leaves your uncommitted and untracked files in the tree, it restores its own
    stash when another worktree changed the stash list, and it keeps changes stashed if a post-checkout hook fails.
  • Rejecting a change keeps edits you saved, even when the save was missed.
  • Non-UTF-8 environment variables no longer stop startup.
  • macOS: the full-screen app no longer freezes in a sandbox that blocks the window server.
  • Typing does not lag when ffmpeg is missing and PATH is slow: the check runs off the drawing path, once.
  • Exiting is reliable. Ctrl+U update-and-quit exits within its deadline, and on Windows Fuigo exits fully after a
    startup error, /minimal, /fullscreen or a signal.
  • Opening links and files no longer leaves a zombie process per click.
  • Short terminals: the cancel-turn prompt and rewind confirmation no longer crash the full-screen app.
  • Kitty graphics: hidden images are freed in the terminal.

Other fixes

  • MCP stdio servers no longer lose part of a long line when a read is interrupted.
  • ! mode Tab completion offers symlinked commands.
  • Custom agent files with a UTF-8 byte order mark load.
  • Sign-in error messages no longer repeat the underlying cause.
  • The always-approve help text says the setting is saved to config. The macOS docs recommend Ctrl+V to paste
    screenshots. Auto-review mode tints the whole prompt bar, like plan and ask. Editing a queued prompt labels and dims
    its row.

From 1.0.41

  • The strict sandbox starts for a non-root user when a container socket sits in a root-only folder (for example
    /run/podman). Such a socket is skipped only when the folder that blocks it belongs to another user. This shipped in
    1.0.41 but was missing from its notes.

Fuigo 1.0.41

Choose a tag to compare

@github-actions github-actions released this 08 Nov 21:01
b6d508f

Fuigo 1.0.41 release notes

Folder trust

  • Trusting a folder mid-session now reloads the session. After you trust a folder, the session loads that folder's
    hooks, plugins and MCP servers. MCP servers whose settings did not change keep running.
  • /trust opens the trust screens in the full-screen app. This folder shows the session folder, its trust key
    and whether it is trusted: t trusts it and u stops trusting it. Trusted folders (Tab) lists every folder
    you trusted, and u stops trusting the selected one. Each change asks you to confirm.
  • A resumed or forked session asks about its own folder. The trust question now names the folder the session was
    recorded in, not the folder you launched from.

Sessions

  • --no-session-persistence keeps a headless run off disk. Nothing is saved under ~/.fuigo/sessions: no session
    folder, prompt history or search index entry. The JSON output still names a session ID, but it cannot be resumed.
    Combined with --resume or --continue it exits 2. An interactive session warns and is saved as usual.
  • One process at a time writes a session. Deleting, renaming or copying a session that is open in another window
    is refused with a clear message instead of racing the other process.
  • /delete starts on Cancel. Pressing Enter once no longer deletes a session.
  • A headless --resume that fails says why. With JSON output, it prints one JSON error that gives the reason.

Hooks

  • SessionEnd command hooks run when a session closes. The end reason is available to the hook's matcher.
  • Project hooks can be disabled per repository. A new disable applies only to the repository you set it in. A
    disable saved by an earlier version keeps applying everywhere, as before. Enabling the hook in a repository removes
    both.

Permissions

  • A permission file that does not load is reported at session start. If a .claude settings file (yours, or a
    trusted project's) exists but cannot be read or is not valid JSON, Fuigo names the file and says its rules did not
    load. Rules that do not parse are listed by file. The session still opens, and every rule that did load applies.

Startup

  • A non-UTF-8 argument no longer crashes startup. This includes a non-UTF-8 --cwd path and the Linux sandbox
    re-launch.

Fuigo 1.0.40

Choose a tag to compare

@github-actions github-actions released this 05 Nov 21:44
28e8e19

Fuigo 1.0.40 release notes

Folder trust

  • An ACP client can ask for a notice after trust is granted mid-session. Set "reopenNotice": true in the
    fuigo/folderTrust client capability. The client then gets one live config_notice: "Folder trust is on. Reopen
    this session to use it." It goes only to the connection that was asked and is not replayed on load. Clients that do
    not opt in see no change.

Pasted images

  • Images pasted with Send Now come back with their placeholder. This holds after cancel (Ctrl+C), after a failed
    send, and after /rewind. After /rewind on a resumed session, the images come from the image stored in the
    session.
  • A missing or invalid stored image is now reported. Before, it was dropped without a word. Now Fuigo says the
    image is no longer available.
  • The transcript shows which images were sent. An [Image #N] placeholder whose image was not actually sent shows
    dim and struck through. This works live and on resume.

Releases

  • The Linux release build now frees runner disk first.

Fuigo 1.0.39

Choose a tag to compare

@github-actions github-actions released this 04 Nov 17:54
1d4f04b

Fuigo 1.0.39 release notes

Subagents

  • Forked subagents no longer get the project instructions twice. A child forked from a session that already holds
    the folder's AGENTS.md and other instruction files now recognises them and does not add a second copy.
  • Subagents get the plugins of the folder they work in. A subagent in another folder (a worktree, or a session
    opened elsewhere) now gets that folder's plugins, not those of the folder Fuigo was launched in, and a plugin edited
    since the last /plugins reload shows up. The check of which agent types exist, and the skills a subagent inherits,
    now use the parent session's own plugins, so they match the agent types the parent offers.
  • A subagent worktree that cannot be created now says why. When a tracked file fails to copy into a new subagent
    worktree, or the disk is full, the subagent stops with that error instead of quietly running in the shared folder.
    Other worktree errors behave as before.

Scheduled tasks

  • Scheduled tasks keep working after a model switch made before the first turn. Before, that switch left the session
    talking to a stopped scheduler, so parking the session and the scheduled tasks of new subagents did not reach it.
  • A scheduled task fires once. Two schedulers sharing one session's state, for example around a model switch, could
    both fire the same task. Each fire is now admitted once. A loop task whose subagent is still running is not started
    again, and that subagent keeps running across a model switch; the loop's next iteration after it starts a fresh
    chain.
  • Shutdown behaves as in 1.0.38.

Settings and commands

  • New [keys] vim setting. vim = "nav" turns on vim-style navigation and vim = "off" turns it off. If
    [ui].vim_mode is also set, it wins, so existing configs behave exactly as before. /vim-mode still changes the
    current session only.
  • fuigo worktree list and show mark a worktree whose folder is missing.

Releases

  • The macOS release build may now run for up to 6 hours, GitHub's limit for hosted runners.

Fuigo 1.0.38

Choose a tag to compare

@github-actions github-actions released this 02 Nov 06:56
233b2d8

Fuigo 1.0.38 release notes

Folder trust

  • Trusting a folder during a session now brings in its project instructions. Before, a folder trusted after a
    session started left that session without the folder's AGENTS.md and other project instruction files, even after
    a later load, while a new session had them. Now the files arrive at the session's next turn and stay there through
    later loads, resumes, compaction, rewinds and forks, with any agent. Each file reaches the model once.
  • A trust answer that arrives just after the first prompt still counts. When a client's trust request is
    outstanding, the first prompt of a session waits up to 2 seconds for the answer, so the instructions land in that
    first request. Sessions in a folder that is already trusted never wait.
  • A client can trust a folder for this run only. A client that shows the folder trust request can reply
    {"outcome":"trust","scope":"configAndCommands","duration":"process"}. The trust lasts until Fuigo exits and nothing
    is written to disk. It grants no more than a normal answer, and a saved or earlier "no" still wins. Any other
    duration value is a rejection. Older Fuigo versions reject this reply, so they stay untrusted.

Two limits remain:

  • Sessions saved by an earlier version are not repaired. If one is missing its project instructions, start a new
    session.
  • A session that gets trust part way through receives the top-level project instruction files. Nested AGENTS.md
    files and project skills arrive with the next new session.

Rate limit messages

  • The retry count now matches what Fuigo does. A rate-limited request now shows "(1/2)" while it waits, and "failed after 2
    attempts" when it gives up, instead of counting against a limit it never reaches. A subagent that runs out of
    retries also reports the number of calls it really made. Retry behaviour itself is unchanged.

Fuigo 1.0.37

Choose a tag to compare

@github-actions github-actions released this 30 Oct 17:11
58f9764

Fuigo 1.0.37 release notes

Windows

  • On Windows, a PATH ending in ; no longer makes every shell command ask. Empty PATH entries (a trailing
    ;, or ;;) mean nothing on Windows, so Fuigo now drops them from the PATH of the shell commands it runs, both
    in its own shell and in an editor's terminal (it sends that PATH with the command when the editor runs it), and
    no longer counts them as an entry that can steer which program runs. A relative entry, ., or an entry inside the
    project still makes commands ask, and macOS and Linux are unchanged (there an empty entry is the current folder).
  • Editor terminals now get the same environment check as Fuigo's own shell. When an editor runs a command for
    Fuigo in its own terminal, a command approved without asking (a read-only command, or one Auto mode approved) is
    now checked against the environment Fuigo sends with it, as Fuigo's own shell already did. If that environment
    can change which program runs (for example a session PATH that puts . or a folder of the project first, from
    your settings or a trusted .envrc), the command does not run and Fuigo says why; an allow rule, your answer or
    "allow all commands" still runs it.

Fuigo 1.0.36

Choose a tag to compare

@github-actions github-actions released this 29 Oct 22:34
50de981

Fuigo 1.0.36 release notes

A permission policy for one launch

A program that launches Fuigo (an editor, a CI job, an embedding app) can now hand it a permission policy for that
run. See Launch Policy.

  • Set it with two variables. FUIGO_POLICY_PATH names the policy file (an absolute path) and
    FUIGO_POLICY_SHA256 must give its sha256. The file holds only a [permission] section in config.toml syntax
    (allow, deny, ask, rules).
  • Per session too. An ACP client can add a policy to one session with _meta["fuigo/permissionPolicyPath"] and
    _meta["fuigo/permissionPolicySha256"] on session/new, and sends both again on every load, resume and fork it
    wants governed. The response confirms it in _meta["fuigo/permissionPolicy"].
  • Its deny and ask win in every mode, always-approve included. An ask from the policy always reaches your client
    as a permission request; remembered approvals don't answer it and answering it remembers nothing. An allow acts
    like your own config: it can remove a default prompt, never a deny or an ask.
  • A bad policy stops Fuigo before it starts. Unknown keys, malformed rules, a relative path, a symlink, a file over
    256 KiB, or a missing or wrong hash: Fuigo prints one JSON line on stderr ({"policy_error": ...}) and exits with
    code 78. fuigo policy check <file> [--json] tests a file the same way and prints its sha256.
  • The file is pinned for the life of the process, and the agent cannot edit it. To change it, start a new process.
  • A governed process runs standalone: no shared leader, and hub routing is refused.
  • Nothing changes when the variables are unset.

Browser mode gives the session back when you leave it

  • Leaving browser_use restores the session's own instructions. Picking default, ask or plan after
    browser_use now gives back the session's own system prompt, its session rules and the client's system prompt,
    exactly as they were. Before, browser mode replaced them and leaving it did not put them back.
  • Browser mode adds to the prompt instead of replacing it. While it is on, the browsing instructions are added
    after the session's own prompt on each request; nothing is stored, and approvals are unchanged.
  • browser_use is reported truthfully. session/set_mode, current_mode_update and modes.currentModeId on a
    live session now say browser_use instead of default.
  • A reloaded session starts in its normal mode. Browser mode lasts for the running session; after a restart the
    session loads in its normal mode (its history replay still shows the earlier switch to Browser).
  • Sessions saved in browser mode by 1.0.35 load with their normal instructions. Session rules that 1.0.35 dropped
    when it entered browser mode were never stored anywhere and cannot be recovered.

Session rules and memory survive mode and model changes

  • Switching model keeps your remembered context. A model switch, or anything else that rebuilds the session's
    instructions, now keeps the memory context and your session rules. Before, the memory context could be lost until
    a restart.
  • Picking default or ask keeps the session's instructions. A default.md or ask.md file now supplies only
    the mode's template: your session rules, the client's system prompt and the memory context stay.

A bare Read rule means file reads

  • Read in allow, deny or ask covers file reads and listings (reading files, listing folders, grep, LSP,
    memory files). It no longer reaches the pure bookkeeping tools (todo_write, ask_user_question,
    scheduler_list, search_tool, refuse_peer_message), so ask = ["Read"] no longer asks on every to-do update
    and deny = ["Read"] no longer blocks them. Every tool that can touch files is still covered; a rule with
    tool = "any" still reaches everything.

Worktree copies report what they could not copy

  • A tracked file that fails to copy stops the worktree. Creating or forking a worktree used to drop such a file
    silently and report success; now the create stops with an error (a full disk says so) and the partial worktree is
    removed.
  • Untracked and ignored files that fail to copy are a warning. One short line ("Worktree created, but 1 file had a
    copy problem: ...") gives the count and the first file; the details are in the log. The same line shows when a
    session is forked or resumed into a worktree, and headless runs print it on stderr.

MCP tools work with more Chat Completions providers

  • Fuigo fills in what MCP tool schemas leave out when it sends them to a custom model over Chat Completions: a
    missing type, an object without properties, an array without items. Some providers rejected those tools.
    Complete schemas are sent unchanged, other API paths and built-in tools are untouched, and a tool is never dropped.