Safety
 / 
Influxx

Influxx Projects, Worktrees, and Isolated Workspaces

Influxx Projects, Worktrees, and Isolated Workspaces
Add projects, create isolated git worktrees, run parallel agents, track board statuses, and clean up workspaces after merge in Influxx.
Influxx is built around projects and isolated workspaces—not a single shared dirty tree. A project is a git repository (or folder workspace) you track in the cockpit. A worktree is a full checkout plus terminals, browser tabs, notes, and UI state bound to that checkout. This guide covers how to add projects, create workspaces, understand isolation, move work across board statuses, and clean up after merge—so you can run one agent or many without stepping on the same files.
In day-to-day use you will see “workspace” and “worktree” used interchangeably in the product: New Workspace creates a git worktree; the sidebar lists workspaces under each project; Delete Workspace removes that worktree after a safety preflight. The isolation unit is always the worktree. When you fan one plan across competing implementations, you create multiple worktrees—each with its own checkout and agent—then keep the winner and delete the rest.
What an Influxx worktree is An Influxx worktree is more than a branch name in a list. It is a tracked git checkout plus metadata, terminals, browser tabs, emulator state, and UI state for that checkout. Internally, each worktree is identified in the form repoId::absolutePath so the app can point agents, diffs, and notes at the correct tree. You always have a main worktree—the primary checkout for the project—and you create feature worktrees for isolated, parallel work. Inactive workspaces can sleep or hibernate so the sidebar stays usable when many experiments are open.
Core ideas:
  • Project: A git repo or folder workspace Influxx tracks in the left sidebar Projects list
  • Main worktree: The primary checkout for day-to-day work on that project
  • Feature worktree: An isolated branch checkout for a task, experiment, or agent run
  • Workspace: The product-facing name for a worktree plus its terminals, browser, notes, and board state
  • ID form: repoId::absolutePath — how Influxx binds UI and agents to a concrete path
  • Sleep / hibernate: Inactive workspaces can rest so you keep many open without drowning the list
Isolation is not a setting—it is the default. Agents do not share a dirty tree. Each worktree gets its own filesystem checkout, terminals, browser pages, and notes so parallel work stays honest.
Add a project Projects are the root of everything else. From the left sidebar, open Add project (or the project dialog). You can open an existing folder on disk, clone a remote URL, import nested multi-repos, or connect an SSH remote host path so agents run on a remote machine with full file editing, git, terminals, reconnect, and port forwards. Non-git folders can still become folder workspaces with attached worktrees. After import, pick or create a worktree to start coding—import alone does not replace selecting a workspace.
Ways to bring a project in:
  • Open an existing folder: Point Influxx at a local path you already use
  • Clone a remote URL: Pull a git remote into a local checkout Influxx will track
  • Import nested multi-repos: Register related repos that live under one tree
  • SSH remote host path: Attach workspaces on a remote box via Settings → SSH Hosts (files, git, terminals, auto-reconnect, Ports panel forwards)
  • Folder workspaces: Non-git folders still work as folder workspaces with attached worktrees
After onboarding, the in-app Getting started / Setup guide tracks real progress, including “Start work in multiple repos” (two or more git projects registered) and “Multi-task” (create at least one non-main worktree). Open the checklist anytime from the sidebar Setup guide entry or Settings → Onboarding checklist. You can also add your first project during onboarding from the notifications step footer, or later from the sidebar.
Where projects and worktrees live in the cockpit Influxx is one multi-tab cockpit: one left sidebar, one middle tab strip. The left sidebar holds Notes, projects and worktrees, setup prompts, Add project, and the setup guide. The center tab strip holds terminals, agents, browser, markdown/editor, emulator, and PR/issue surfaces for the selected workspace. The right activity bar includes Explorer, Agents (AI Vault), Source Control, Checks, Ports (for SSH), and Attached worktrees. The status bar surfaces usage meters, connection pills, and integration status.
Navigation that keeps you in the worktree:
  • Switch worktree / palette: ⌘J on macOS · Ctrl+Shift+J on Windows/Linux
  • Create worktree (New Workspace): ⌘N / Ctrl+N (also ⌘⇧N)
  • Focus worktree list: Mod+0
  • Select workspace 1–9: Mod+1 … Mod+9
  • Show Explorer: ⌘⇧E / Ctrl+Shift+E
  • Show Source Control: ⌘⇧G / Ctrl+Shift+G
  • Toggle left sidebar: ⌘B / Ctrl+B
Create a workspace Open New Workspace with ⌘N / Ctrl+N (or start creation from the worktree/command palette). In the composer, pick the project or repo, the agent, the prompt, the base branch, and the setup policy. Optionally link a GitHub, GitLab, or Linear task and enable smart naming. Confirm—Influxx creates the git worktree and can launch the agent in the first terminal. You can also start a workspace from the Tasks page when an issue is ready, or from the CLI when scripting fleets of experiments.
The New Workspace composer is the primary UI path: project, agent, prompt, base branch, then create worktree and launch. Other entry points include the tab strip (new terminal / new agent / Quick Commands), Sidebar note Run (context pack plus CLI tab from a plan), Tasks (start workspace from a GitHub, Linear, or Jira item), Automations (scheduled prompt runs), and the Influxx CLI (worktree create with agent and prompt, or terminal create with a command).
CLI: create worktrees and second agents With the Influxx CLI registered (optional; from Settings after install), you can drive the same cockpit from the shell. Create a named worktree with an agent and prompt, then attach another agent to the same active checkout when you want two CLIs on one tree without a second filesystem isolation boundary.
Example pattern (command name is influxx; Linux PATH installs may use influxx-ide; dev builds may use influxx-dev—the command tree is the same):
influxx worktree create --name feat-auth --agent codex --prompt "Implement OAuth" --json
influxx terminal create --worktree active --command "claude" --json
Useful worktree CLI verbs:
  • list / show / current: See worktrees and which one is active
  • create: --name, optional --agent, --prompt, --no-parent, --json
  • set: Update metadata such as --comment
  • rm: Remove a worktree by id
  • ps: Orchestration summary across worktrees
Isolation model Isolation means separate filesystem checkouts: agents do not share a dirty tree. Each worktree owns its terminals, browser pages, emulator state, and .influxx/notes. Setup scripts and hooks can run when a worktree is created; the create flow accepts a setup policy of run, skip, or inherit (--setup run|skip|inherit). Sparse checkout presets are available in the composer when you only need part of a large repo. Parent lineage supports stacked work; use --no-parent for independent experiments that should not inherit a parent chain.
What stays per-worktree:
  • Checkout: A real git worktree path—not a shared branch dirty with everyone else’s edits
  • Terminals and agents: Worktree-scoped PTYs; each agent tab is a real shell session in that tree
  • Browser pages: Embedded browser tabs bound to the workspace
  • Emulator state: Emulator UI and state for that workspace when you use it
  • Notes: Sidebar project notes under .influxx/notes/ in the worktree (plans bound to that workspace)
  • Review notes and comments: Diff line notes and the sticky workspace comment live in worktree metadata
  • Setup hooks: Per-repo setup scripts (for example install deps, write env files) on create when policy allows
Parallel agents use the worktree as the isolation unit. Fan one prompt across many agents by creating multiple worktrees—each with its own checkout and agent. Compare diffs, keep the winner, delete the rest. For a second agent on the same checkout, open a new terminal with a different CLI command instead of a new worktree. The Workspace Board tracks Todo, In progress, In review, and Done across those units so multi-task work stays legible.
Stacked work vs independent experiments Parent lineage is for stacked work: a feature worktree can sit in a chain so later work builds on earlier isolation. When you want independent experiments—same prompt, competing approaches—create sibling worktrees with --no-parent (CLI) or the equivalent independent option in the product flow so they do not inherit parent lineage. Smart naming and optional task links (GitHub / GitLab / Linear) help you recognize each experiment on the board and in the palette.
Setup hooks and sparse checkouts Per-repo setup scripts and hooks run when a worktree is created so you can automate npm install, env files, and other bootstrap steps. Configure them under project or repository setup; the Getting started checklist tracks “Automate workspace setup.” In the New Workspace composer you choose setup policy (run, skip, or inherit) so a one-off experiment does not have to reinstall the world if you already know the tree is ready. Sparse checkout presets in the composer keep large monorepos lean when an agent only needs a slice of the tree.
Board and statuses The Workspace Board is a kanban view over four statuses: Todo, In progress, In review, and Done. Use it to see every workspace’s stage without opening each terminal. The sidebar supports group-by, smart sort, and filters for sleeping workspaces so long-running or parked work does not hide active agents. Set a sticky comment on a worktree via Edit Worktree Details in the UI (Comment field; markdown-lite supported) or via the CLI: worktree set --comment. A non-empty comment shows a Workspace notes badge on the card; hover the card for the rendered comment and Edit notes. Comments are searchable in the worktree palette—they are short sticky fields on the worktree, not documents in .influxx/notes.
Board statuses:
  • Todo: Created or queued; not actively coding yet
  • In progress: Agent or you are working in that worktree
  • In review: Diffs and PR checks need human attention
  • Done: Work accepted; ready for merge cleanup or archival sleep
Workspace comments are not the same as Sidebar notes or review notes. Sidebar notes are markdown files under .influxx/notes/ for plans you Run into an agent. Review notes are line comments on diffs you send back to an agent (stored in worktree metadata, not as host PR review comments unless you also use host review). The board comment is the one-liner that makes a card scannable in a multi-workspace day.
From plan to parallel workspaces Write a plan in a Sidebar note (left rail, above the worktree list; files live under .influxx/notes/). Run the note so an agent receives it as truth. Iterate with review notes on the resulting diff. Optionally create sibling worktrees with the same plan for competing approaches—New Workspace with the same prompt across multiple worktrees, or CLI create with --no-parent for independent experiments. Merge the winner on the git host; delete the rest in Influxx.
Source control, PRs, and checks (still on the worktree) Source Control lives in the right sidebar (⌘⇧G / Ctrl+Shift+G). Stage, unstage, commit (optional AI commit message), push, and open changed files in the editor. Providers include GitHub, GitLab, Bitbucket, Azure DevOps, and Gitea. Drop line comments on any diff and send them back to the agent without leaving Influxx. Create PR / MR from the in-app composers (GitHub and GitLab paths are first-class). Link worktrees to issues and PRs via Edit Worktree Details (GH issue / GH PR fields). Checks and PR Checks panels surface CI status so you can wait on green without context-switching—unless you want the embedded browser for the PR page itself.
Merge and cleanup There is no special “merge worktree” product verb beyond git. The flow is: the agent works in a feature worktree; you review diffs, annotate, commit, and push from Source Control; you create a PR or MR and watch Checks / PR Checks; you merge on the git host (GitHub, GitLab, or your provider). After the branch is merged (or abandoned), delete the workspace in the UI—Delete Workspace runs a preflight for dirty state and lineage—or remove it from the CLI with worktree rm. Sleeping workspaces and board Done status help you park work before you remove it.
Merge & cleanup sequence:
  • 1. Work: Agent (or you) codes in a feature worktree
  • 2. Review: Diffs, annotate with review notes, commit, push from Source Control
  • 3. Host review: Create PR/MR; watch Checks / PR Checks in-app
  • 4. Merge: Merge on the git host—Influxx does not invent a separate merge-worktree action
  • 5. Delete: Delete Workspace in the UI (preflight for dirty state / lineage) or influxx worktree rm
Preflight matters: if the worktree is dirty or sits in a parent lineage, the product warns before removal so you do not discard uncommitted work or break stacked dependents by accident. Prefer merging (or explicitly abandoning) and cleaning the tree before delete when the preflight complains. Losing a worktree does not un-merge a PR on the host—cleanup is local product state plus the git worktree checkout, not host history.
Floating Workspace vs repo worktrees Floating Workspace is a separate panel for terminals and markdown that are not tied to a repo worktree. Enable it under Settings → Floating Workspace. Markdown there is saved in Influxx’s app-owned floating-workspace directory, not your home folder, even if terminals start in $HOME. Floating notes do not appear in the per-worktree Sidebar Notes list—they use a different storage root. Use Floating Workspace for cross-project scratch; use project worktrees for anything that should ship as code.
Remote machines and multi-repo days For remote machines, use SSH Hosts so agents run on a beefy box with full file editing, git, terminals, reconnect, and port forwards. Settings → SSH Hosts manages files, terminals, Git, and workspaces on remote machines; auto-reconnect and the Ports panel apply to SSH repos. Add a remote host from the sidebar when attaching a new machine. SSH and remote worktrees use the same relative paths (including .influxx/notes); filesystem ops go through the remote connection. When you work across many repos, register each project, create non-main worktrees for multi-tasking, and rely on group-by, smart sort, and sleeping filters so the board stays navigable.
Related product surfaces:
  • Tasks page: Start a workspace from a GitHub, Linear, or Jira item
  • Integrations: Settings → Integrations for git providers and task sources
  • Sidebar notes: Plans under .influxx/notes/ with Run into an agent
  • Source Control: Stage, commit, push, PR/MR, annotate diffs
  • Checks: CI status without leaving the cockpit
  • CLI recipes: Parallel experiments with two worktree create --no-parent commands and different agents
Practical recipe: parallel experiment From the CLI (or twice from New Workspace with the same prompt): create two independent worktrees with different agents, same goal. Example: one worktree named exp-a with Codex, one named exp-b with Claude, both --no-parent and the same prompt. Compare diffs in Source Control, promote the winner through PR and merge on the host, then Delete Workspace (or worktree rm) on the losers. Track both cards on the Workspace Board from Todo through Done so nothing is forgotten in sleep.
Trust presets can pre-mark some agent workspaces so the first paste is not eaten by trust menus; that does not bypass agent sandboxes. Agents remain worktree-scoped PTYs—the cockpit tracks status, usage, notifications, and history; it does not replace your CLI’s own tools. Prefer the local CLI path for production work; managed credits are an optional lane where available.
Projects hold the repos. Worktrees hold the isolation. The board holds the status. Merge on the host; clean up in Influxx. That loop is how multi-agent work stays safe and finishable.
Quick reference: project → workspace → ship Add a project from the left sidebar. Select the main worktree or create a feature workspace with New Workspace (⌘N). Let setup hooks run if the repo needs them. Launch or attach agents in that worktree only. Move the card across Todo → In progress → In review → Done. Review, commit, push, open PR/MR, wait on Checks. Merge on GitHub, GitLab, or your host. Delete Workspace when preflight is clean—or sleep the workspace until you are ready. For competing ideas, multiply worktrees, not agents on one dirty tree.
If something fails at create time, confirm a workspace is selected where the UI requires one, check that the project path is still valid (especially for SSH remotes after reconnect), and retry setup policy if hooks failed midway. Use the worktree palette (⌘J / Ctrl+Shift+J) to jump, the board filters to find sleeping work, and Edit Worktree Details to keep comments and GH issue / PR links current so the cockpit matches the work on the host.