⚠️ Unofficial. This is a community extension and is not affiliated with, endorsed by, or sponsored by Anthropic. "Claude" and "Claude Code" are trademarks of Anthropic.

Why

Features

🗂 Changes

Mission Control's own change tracking — no git involved. Like Copilot's edit review: the first open snapshots your workspace as the baseline; from then on every change to a recognized developer file (by you, Claude, or a script) shows up with +/- stats. Click a row for a diff vs the last accepted version, Accept to approve it (the baseline moves forward), Undo to restore the last accepted version (new files are deleted, deleted files come back). Accept all and Undo all sit in the header. Works in any folder — git repo or not.

Signal only, by design. Tracking is allowlist-based: ~140 source, markup, config and project file extensions plus ~65 exact names (Makefile, Podfile, Dockerfile, .gitignore, …). Everything else is deliberately invisible, so build output and IDE junk never pollute the list — node_modules, dist, build, Pods, DerivedData, vendor, any dot-folder, *.xcresult / *.xcarchive bundles, media and binaries, and .DS_Store-style OS files. Brand-new files over 1 MB aren't picked up either. Working in a format Mission Control doesn't know? Add it with missionControl.tracking.alsoTrack — an extension (.xyz) or an exact name (Procfile) — and it applies live, no reload. (Known binary/media types stay out regardless.)

Moved a folder and everything looks NEW? Mission Control matches moved files by content automatically, and if a baseline really has gone stale it offers a one-click Re-baseline — also available any time from the Command Palette. Re-baselining never touches your files, only Mission Control's record of what you've accepted.

Mission Control tracks the first folder of your workspace.

How this differs from Claude Code's own review. Claude Code offers Accept / Reject per edit before it lands, and Rewind per turn — and its own dialog says "Rewinding does not affect files edited manually or via bash." Mission Control's Changes tab is cumulative: every on-disk change by anyone, per file, since the state you last accepted, with or without git.

📋 Plans

Browse the plans Claude produced in plan mode — expand inline as rendered markdown, or hit ↗ to open a plan in a styled, read-only plan view tab (like Claude Code's own plan review). Scope it to this project or to every saved plan with missionControl.plans.scope.

Plans are read from Claude Code's global folder and, when a project sets plansDirectory, from the project's own folder too. A plan a subagent wrote is listed with a subagent tag; the workshop and rejected-ultraplan drafts Claude Code leaves beside a plan are not plans and are not listed. Claude Code deletes old plans in its periodic cleanup, and the tab says so when the folder is gone rather than looking empty for no reason. Claude Code itself opens only the live plan; this is the archive.

📊 Plan usage

At the top of the panel, on every tab: live 5-hour and weekly limits — including any per-model weekly limit your plan has, such as Weekly Fable — with percentage, reset countdown and last-checked time, read using Claude Code's own local credential — shown next to what the work would have cost, and flagged when a reading's reset time has already passed. If your plan has usage credits switched on, a row under the limits shows how much of the monthly limit is used and what you have spent, worked out the way Claude Code's own /usage does. When a reading has stopped moving, hovering it says why: the check is being rate-limited, or your sign-in needs refreshing (opening Claude Code does that). Optional and fully disableable — this is the only part of Mission Control that touches the network.

⚙️ Subagents

The control that saves money. Three buttons under Subagents — Opus · Sonnet · Haiku — set the model your subagents, agent teams and workflow agents run on while you stay on your main model. Under them, a second row sets how hard those agents think, their effort. Agent-heavy work is where tokens actually go, so this is the single biggest saving available, and it's one click instead of hand-editing settings.

• Writes env.CLAUDE_CODE_SUBAGENT_MODEL in ~/.claude/settings.json. Takes effect on the next subagent spawned; no restart.
• Since Claude Code 2.1.251 that key is a default, not an override: an agent whose definition names a model, or a spawn that asks for one, keeps its own. The override (CLAUDE_CODE_SUBAGENT_MODEL_FORCE) is no longer offered — it takes the choice away from every agent and workflow, which is rarely wanted. If it is already on, set by hand or by an older version, the panel shows it with a plain way to turn it off.
• With no model set, agents follow your chat's model, and the card says so. There is no Inherit button: every button is a model something really runs on. A key the panel switches off is written as a value, never deleted. Claude Code re-applies a changed settings file to chats that are already open, but never unsets a key that disappeared from it.
• The buttons write Claude Code's own aliases, so Sonnet is whichever Sonnet Claude Code means today: Sonnet 5.5 since Claude Code 2.1.284.
• The effort row shows only the levels the subagent model has, with the one its agents start at pressed. That is its default (Medium on Opus, Sonnet and Haiku 5.5) until you pick another. All three 5.5 models have Low · Medium · High · Extra high · Max.
  • Claude Code has no effort setting of its own for subagents. An agent starts at the effort saved for its model, or that model's default (Medium on the 5.5 models), unless you pick an effort in the chat itself or the agent asks for one. That is how Sonnet agents under an Extra high Opus chat ended up at Medium.
  • Low to Extra high are saved for the subagent model under modelSettings, where Claude Code's own /model saves them. They reach chats you start afterwards, including chats on that same model.
  • Max is the one level Claude Code won't save per model. It is set for everything, your chat too (CLAUDE_CODE_EFFORT_LEVEL), and switched off by value like the keys above.
  • Also for agents that ask for their own sets the level for every chat and agent the same way. A workflow or an Agent call can ask an agent for its own effort, and that ask beats a level saved per model. This is the one setting Claude Code ranks above it. Your chat runs at it too.
  • The Tasks tab shows the model and effort each agent actually ran at, and what its run would have cost.
• Every write is guarded: if settings.json isn't valid JSON right now, Mission Control changes nothing and tells you, instead of clobbering your hooks, permissions and env.

The model buttons never touch your main agent. Effort can, and the card says when:

• a level is saved per model, so chats on the subagent model start there too;
• Max applies to every chat.

Otherwise your own model and effort are set in Claude Code's composer (/model, /effort).

💸 What it would have cost

Mission Control prices this project's work at Anthropic's published API rates — today and over the last 7 days, and per agent in the Tasks tab. On a subscription no money moved, so it is shown as a comparison and never as a bill: the useful reading is what a flat plan is covering.

Every figure is computed on your machine from the token counts Claude Code already writes to its own logs — nothing is sent anywhere to produce it. Each response is priced by the rates that apply to that response (fast mode's premium, a model's own cache-read rate, Haiku 5.5's long-prompt rate, a price change from the day it took effect), sub-agent and workflow transcripts are counted as well as the main session, and a response split across several log records is charged once rather than three times — by its final count, which in an agent's log is the last record and not the first. Since 2.1.286 Claude Code does not write the final count for most of an agent's tool-calling steps at all; those are read off the countdown of tokens left that it writes after each tool result, and only when the figure checks out against the next step. Where a model has no published rate — a local model behind a custom backend, or a model released after this version — its tokens are counted but its dollars are not, and the card says so: the last request shows a dash rather than an older priced one, and every figure missing it says it is incomplete.

Those figures survive a tidy-up. Claude Code's logs get cleaned — by its own retention sweep, by a cleanup script, or by hand — and until 1.10.0 the spend they recorded went with them, which on this machine was 37% of a week. Mission Control keeps its own small record of what each piece of work cost, outside those logs. It holds amounts and token counts only, never any part of a conversation, and runs to a few megabytes a year; missionControl.storage.recordSpend turns it off. It cannot recover what was lost before it existed, and it marks a figure as "at least this much" rather than exact whenever there is a stretch no panel was open for.

Claude Code's own session view shows what one chat cost. This card adds up every chat, agent and workflow in the project, by day and by week, and keeps the figure after the logs are gone.

It can read a little higher than Claude Code's own /cost, on purpose: a response that was retried on another model is charged for every call it made, where /cost counts only the last one. Web searches are charged per search, as the price list does. The rates were last checked against the live price list and against Claude Code 2.1.300 on 15 October 2026, when Haiku 5.5 was added and Sonnet 5.5's cache reads were halved from 7 October (docs/AUDIT-pricing-2026-10-15.md has the full audit).

🧹 Storage

What Claude Code is keeping on this Mac, and what can go. Sizes in plain words, a sentence saying what each thing is, and beside it the list of everything that is never touched — your chats, anything a running chat owns, your memory and skills and settings, and the record of what your work cost.

Cleaning moves things to a trash rather than deleting them; anything cleaned can be put back for seven days, or you can empty it yourself. A chat is never removed by age — only one you archived in the session list, and if that list can't be read, none are considered at all. An archived chat leaves with its own notes, and the panel says what that costs first: you can't reopen it, and a plan saved from it drops off that project's list. What it cost stays. Whether a chat is running is read from the running process, never from how quiet its files look, so a long tool call or a background loop is never mistaken for finished. missionControl.storage.enabled hides the tab.

🤖 Background tasks

A live view of background work with accurate statuses (running / completed / stopped), read from Claude Code's own task lifecycle records. Active and Cleared are separate panes, so clearing something files it away rather than destroying it — anything cleared can be put back. Clear all heads the finished cards ("Finished", with the button on its right when you point at the list), under the work that is still running, and Restore all heads the cleared ones; there is no blank row above the list. Workflow runs group their agents under one expandable card with a progress bar over them. Each agent is named the way the workflow named it, with repeats numbered ("verify · 2"), and shows the phase it started in. Tool calls from an MCP server read as words ("Play Store · get earnings"), not as mcp__play-store__get_earnings.

Every agent card reads at a glance:

• Now, while it runs: the step it is in and for how long;
• Model, with effort;
• Time, Tokens and Cost on one line, lined up from card to card. One moves to the next line whole when the sidebar is narrow.

Tool calls and thinking time are in the tooltips, and step by step when you open the agent.

How it ended is told in a word. A card shows a spinning ring while it runs and a ✓ when it finished. When it ended early the word says how: Stopped (you or Claude stopped it), Failed (with the reason in the tooltip), Timed out or Interrupted (Claude restarted before it finished). Tasks that a restart cut off are one quiet line at the end of the list, "3 tasks ended when Claude restarted", not three cards claiming to run.

A command reads like a terminal. A background command's card shows its output the way a terminal does: colours, and a progress bar that redraws in place, so a download shows how far it has got. It keeps up while the command runs, and Open in terminal follows it in a VS Code terminal tab. Whether a command is still running is read from the files it holds open, not from how long it has been quiet, so a long build piped through tail, which prints nothing until the end, stays Running. A command that was sent to the background says "Moved to background".

A Monitor shows its events. Its card shows the command it watches, then each event with its time, newest at the bottom. It says Watching while it runs and how it ended after: "Stream ended", or "Expired after 25m". Events are fetched when you open the card; the card on the list carries only the count.

What an agent started sits inside its card. The commands, Monitors and agents an agent started are drawn inside it when you open it. A card runs while anything it started runs, so it can't be cleared until that has ended. An agent that is retrying a failed request says "Retrying · attempt 3" (a guess from repeated requests, and the tooltip says so).

A chat that started another is a card too. A side chat, or a fork, gets a card with where it came from and Open in Claude, which opens the chat in Claude Code. A side chat is matched to the chat that started it by the brief it began with, so the match can be wrong and its tooltip says so; a fork is exact. Only the newest ten from the last week are cards. A chat that is open in another app (a terminal, the desktop app) is not opened from a card: the button says "This chat is open in another app." Without Claude Code it says "Claude Code isn't installed."

Open an agent to read it the way Claude Code shows a conversation. You see the prompt it was given, every step drawn the way Claude Code draws it (below), with what it ran and what came back, how long it thought, messages sent to it mid-run ("You sent", "Agent replied"), and a live line while it works. Its answer sits at the top once it has one. That includes the report a subagent hands back in auto mode, which also marks it done the moment it does. Open in tab gives it a whole editor. An agent you message again after it finished shows as working again, and its view keeps up.

• Each step is drawn as Claude Code draws it, not as raw JSON. A TodoWrite is "Update Todos" over the same checklist as the TODO dock. A command is its description over a $ command block and its output, five lines with "Show 12 more lines" under them, and "Failed" over the error when it failed. A Read is its path, the lines it asked for and "42 lines", which opens the text. An Edit is "Update", its path and "Added 3 lines, removed 1 line" over a line diff in the Changes tab's colours. A Write, a search, a fetch, an agent, a skill: each its own. A path on a step is the button that opens the file. Under a card a step opens on a click; in Open in tab the steps that have a drawing start open. A tool nobody has drawn, such as an MCP call, keeps its raw input and output. A call's input is kept to 8 KiB, and a long string is cut rather than the JSON, so even a big edit still draws.
• A compaction is a line of its own, "Summarised · 646k to 23k tokens".
• A question Claude asked shows its options and the one you picked, with a tick and the word Picked. One still waiting says "Waiting for your answer".
• A call that didn't run says why on the call: You declined, Blocked by auto mode, Auto mode was unavailable or Blocked by a rule. Open it for the reason Claude Code gave.
• When a result was too long, Claude Code saved it beside the chat. The preview stays, and Open full output shows the whole of it in a read-only editor tab.
• Claude's text shows tables, lists, links and emphasis. A link opens in your browser, and only http and https ones.

The Tasks tab is hidden by missionControl.backgroundTasks.enabled, and the TODO list goes with it. The agent's tab and a command's terminal keep working with it off.

✅ TODO list

Claude's TODO list, at the bottom of every tab. It is the same list on Changes, Plans, Tasks, Context and Storage, and it is there only when a chat has a list. Folded it is two lines: the chat's name ("TODO · Personal AI") with "3 of 7", then a bar and "Now: Fixing the cost undercount" (or "Next:" before a step is begun). Open it for every step, drawn the way Claude Code draws its own list: an empty box is waiting, a box with a tick is done (the step struck through), and Claude's turning ✻ marks the step it is on.

• Drag the top edge to set its height, or press the up and down arrow keys on the edge. Double-click puts it back. The height is kept, and it is the same after a reload. It stops at 70% of the panel, or sooner in a short window, so the tab above it keeps a few rows.
• A list nobody has touched for a day, or that is all done, says "Last list · 3d ago", never "Now".
• Earlier lists stay one click away, each folded to its first step.
• With two or more chats that have a list, they are tabs at the top of the open dock, each with its own count ("Personal AI 3 of 7"), the chosen one a filled segment. The row is one line and scrolls sideways when there are more than fit; a long name is cut and shown whole in its tooltip. Left, Right, Home and End move between them.
• Chats started from VS Code get no TODO tool by default (as of Claude Code 2.1.314). The Claude Code extension turns it off, and the current models don't get it back on their own. When no chat has a list, the dock offers one line, Let Claude keep one, which turns the tool on for chats you start from then on. It sets CLAUDE_CODE_ENABLE_TODO_TOOLS in ~/.claude/settings.json. Once it is on the line goes away, and nothing in the panel turns it off: the open dock has no switch for it.

The first read of a big chat doesn't hold your editor. After a reload, the Tasks list, the TODO list and the plans are read in short turns, newest chat first, instead of in one go. On a 158 MB chat the longest turn measured 71 to 77 ms, and everything is on screen in about two seconds. A workflow run of hundreds of agents (492 agents and 730 MB of transcripts here) is read the same way, a slice a turn, and its card appears when it has been read whole: the longest turn is 70 to 81 ms there.

🧩 Context

What fills a chat's context window, and how much room is left. The Context tab, between Tasks and Storage, draws a chat the way Claude Code's own Context view does: the percent used ("24%") and "237.4k of 1M tokens · Opus 5.5", one bar with a colour for each part of the window, and a row for each part: Messages, MCP tools, System tools, Memory files, System prompt, Skills, MCP instructions, the Autocompact buffer and Free space. Nothing that is empty is drawn. With two or more chats open in Claude Code they are tabs at the top (a closed or archived chat is not one), and the panel opens on the chat Claude is in.

• Memory files, skills and MCP tools open into a list. The MCP tools by server, biggest first; each memory file and each skill with its tokens. Press a memory file or a skill to open it in an editor tab.
• A ~ marks an estimate. Claude Code counts each part with the token-count API and writes none of that down, and Mission Control has no way to ask it, so it works the numbers out from the chat's own log. The amount used, the window, the percent, the autocompact buffer and the free space are exact. Every row for a part, and each file's and tool's tokens, are estimates worked out from lengths, and so is the amount used for a chat that was compacted and has not been answered since. The footnote says "~ estimated" and how old the numbers are.
• It keeps up. It reads when you open the tab, when you choose a chat, and every 10 seconds while the tab is on screen. A big chat is read in turns (about 8 MB or 40 ms a turn), like the rest of the panel, so it doesn't hold your editor.
• The window follows your settings. autoCompactWindow and autoCompactEnabled in your user, project and local settings are read (and nothing else in them). CLAUDE_CODE_AUTO_COMPACT_WINDOW set in a shell is not seen, so the window can differ from Claude Code's then.

📐 Fits a narrow sidebar

The panel's content is up to 431px wide, centred in anything wider. The five tabs always fit one row, with 16px between their names. As the sidebar narrows the strip gives up words first ("3 running" becomes a dot and a number) and half of that air, and when the labels still don't fit it turns into one icon for each tab with its count beside it and the name in the tooltip. It never wraps and never cuts a tab short: with counts up to 99 on every tab it is one row of whole tabs from a 200px sidebar up. In a sidebar under 260px the Changes header's Accept all and Undo all are their icons too, so the tab doesn't scroll sideways.

🔔 Ping me when Claude needs you

Step away while Claude works. When its turn ends — or when it's blocked on a question or a plan awaiting approval — Mission Control fires a native OS notification with sound that reaches you even over a fullscreen app. It only fires when that window isn't focused, and each window checks its own focus, so a finish in a background window pings you while you keep working in another. Every chat in the folder is followed separately, so a busy session can't swallow another one's ping, and two windows open on the same project won't both announce the same turn.

On macOS (Apple Silicon) and Windows, clicking the notification focuses the exact VS Code window that workspace is open in — macOS uses a bundled signed + notarized helper so the click still works on current macOS. Intel Macs fall back to a non-clickable banner; Linux uses notify-send (not clickable), with an in-app notification if notify-send is missing.

A Monitor left watching, or a command an agent left running, doesn't hold the ping back: a Monitor may run for hours, and waiting for it would mean never hearing that Claude finished.

With several agents or commands running you get one ping, when the last of them has reported and Claude has answered it, not one for each report on the way. A question or a plan to approve still pings at once.

Off by default — flip the bell switch in the controls row at the top of the panel, or set missionControl.notifyOnComplete. While it is off Mission Control reads nothing for it.

It stays quiet for the chat you're sitting in: if the window is focused and you've touched the keyboard or mouse in the last few minutes, an answer you're already reading doesn't ping. Step away and it does, however long the run — that's the whole reason to be told. To be pinged for every completion regardless, turn off missionControl.silenceWhenWatching.

Commands

All from the Command Palette (⇧⌘P / Ctrl+Shift+P), prefixed Claude Mission Control:

Your own model and effort are Claude Code's business: change them in its composer, or with /model and /effort. The one exception is the Subagents card's Also for agents that ask for their own switch, which Max always turns on: it sets the effort for your chat too.

Privacy — what Mission Control touches

Everything happens on your machine. Mission Control runs no servers, collects no telemetry or analytics, and makes exactly one network request — described at the end.

What it reads

• Your local Claude Code data in ~/.claude — sessions, plans, settings.json, task records. That includes which Claude Code sessions are open right now, and where each runs (the small files in ~/.claude/sessions), to know which chats are working and which are open in another app.
• A chat's context, for the Context tab. It reads the end of a chat's log, and the part since its last compaction, to count what is in the window; the memory files Claude Code loaded for the chat (CLAUDE.md files and the auto-memory index), from the log or, when the log recorded none, from where they live on disk; and the keys autoCompactWindow and autoCompactEnabled from your user, project and local settings.json, and nothing else in those files. Only the amounts are drawn; nothing is sent anywhere.
• Your chats, for the Tasks and TODO. A side chat's card and the TODO list read each chat's title from those same logs, and show only that in the panel; nothing about it is sent anywhere. The TODO list, the Monitors' events and an agent's page are read from the same logs, and a result Claude Code saved beside a chat is opened only from that chat's own folder.
• Background-task output from Claude Code's own temp dir: /tmp/claude-<uid> (macOS/Linux) or \tmp\claude-0 on the current drive (Windows — Claude Code has no Windows branch here, so it builds the same POSIX-shaped path).
• The Claude Code extension's claudeCode.environmentVariables setting and the environment VS Code was started with, since chats started from VS Code run with both. Only the variables behind the Subagents card and the TODO switch are used: the subagent model and effort settings, the workflow agents' model, what the model aliases point to, and whether the TODO tool is on. Nothing else in them is shown or kept.
• For the Changes tab, files in the folder you have open — but only the recognized developer files described above. .env files, keystores, certificates, binaries, media, build output, node_modules and dot-directories are never read.
• On macOS, the Plan usage card reads Claude Code's OAuth token from your login keychain (item Claude Code-credentials) — that's where Claude Code keeps it instead of ~/.claude/.credentials.json. Turn the usage card off and this read never happens.

What it writes

• To make Undo possible without git, Mission Control keeps its own copy of the last accepted version of every tracked file under ~/.claude/.mission-control/tracking/<workspace>/. These copies never leave your disk — delete that folder any time to wipe them, and baselines for folders that no longer exist are pruned automatically after 30 days. Note the copy is of the file as-is: if a tracked source or config file contains a credential, so does the copy. Real .env files are never copied (.env.example / .sample / .template are).

• Your workspace files are written only when you click Undo (or run Undo All Tracked Changes) — that's what Undo is. Accept and Re-baseline move Mission Control's own baseline and never touch your files.

• ~/.claude/settings.json: only what the Subagents card and the TODO dock set, merged into the file, and only when you click. That is:

  • the two subagent env keys, CLAUDE_CODE_SUBAGENT_MODEL and CLAUDE_CODE_SUBAGENT_MODEL_FORCE;
  • the effort lock, CLAUDE_CODE_EFFORT_LEVEL;
  • the subagent model's effortLevel under modelSettings;
  • the TODO tool, CLAUDE_CODE_ENABLE_TODO_TOOLS, set to 1 when you press Let Claude keep one and never removed or turned off from here (to turn it off, edit the file).

  Every other key is left exactly as it was. If that file isn't valid JSON, Mission Control refuses to write at all.

• With missionControl.notifyOnComplete on, macOS: the bundled notification helper is copied to ~/.claude/.mission-control/bin/ (and de-quarantined) so clickable notifications work.

• Small bookkeeping files in ~/.claude/.mission-control/, none of them sensitive: usage-cache.json (your last usage reading, so the card isn't blank on open), dismissed-tasks.json (which task cards you cleared), notify-claims/*.claim (which window announced which turn, so two windows on one project don't both ping), and inside tracking/ a .last-prune marker plus one .owner file per workspace. Older builds also left a usage-history.json there; nothing reads it any more and it is safe to delete.

What it runs. A few commands on your own machine, each for one job:

• lsof, on the output files of Claude Code's background commands, to tell a command that is still running from one that ended (macOS and Linux; on Windows the card reads it from the time instead);
• security, for the keychain read above;
• sqlite3, read-only, so the Storage tab knows which chats you archived, and the TODO dock and the Context tab leave them out;
• ps (macOS and Linux), once per check, for the start time of the Claude Code sessions listed in ~/.claude/sessions, so a session that is still open is told from one whose process id was reused (the .key files beside them are never opened);
• for notifications: alerter / osascript / open on macOS, powershell.exe on Windows, notify-send on Linux.

What it opens. A memory file or a skill you press in the Context tab opens in an editor tab, only if the tab itself listed it, and never a file that holds a secret. A link in Claude's text opens in your browser when you click it, and only if it is an http or https address (one with a user name or password in it is refused). The Buy me a coffee button opens an https address. Open full output and Open in terminal open a read-only editor tab and a VS Code terminal tab. Mission Control refuses to open Claude Code's sign-in file, its session keys and its editor-bridge files, even through a link. The terminal tab only shows a command's output: what a command printed can colour it, but not write to your clipboard, open a link or retitle the tab.

The one network call: the Plan usage card sends Claude Code's own local OAuth token to Anthropic's usage endpoint (api.anthropic.com) to read your 5-hour and weekly limits. Nothing else is sent anywhere. Set "missionControl.usage.enabled": false and Mission Control is fully offline.

Don't take my word for any of it. The source is on GitHub, so you can read exactly what it does before you trust it with your ~/.claude. It isn't open source, and the licence says so, but nothing about it is hidden. Questions still get answered: supportcutex@gmail.com.

Requirements

• VS Code 1.89+
• Claude Code installed and used at least once (so ~/.claude exists).
• A local workspace — Mission Control needs real filesystem access, so remote virtual workspaces aren't supported.

Settings

Support

Mission Control is free and unofficial. If it saves you time, there's a Buy me a coffee cup in the panel's controls row, visible on every tab, which opens my GitHub Sponsors page. Entirely optional, and there's no tracking either way.

Questions or a bug? Email supportcutex@gmail.com (also linked inside the panel's controls row), or open an issue on GitHub.

Built by Suraj Kumavat. @levelupwithsk on Instagram.

License

Proprietary © Suraj Kumavat. Free to install and use. The source is published so you can read it, but publishing it doesn't make it open source: you may view, clone, fork and modify it for yourself, not redistribute or sell it. Full terms in LICENSE, which also ships with the extension as LICENSE.txt. Bundled third-party components keep their own licences, listed in THIRD-PARTY-LICENSES.md.