thinQit Cody

Your thinQit coding teammate in VS Code. Ask a question or describe a change, let Cody do the work at thinQit, and review every file it touches right in your editor.

What it does

• A panel of its own. Open thinQit Cody from the activity bar. The Q becomes the green presence sphere when you sign in, breathes while Cody works and flashes once when a task ends.
• Any repository. GitHub, Azure DevOps, GitLab, Bitbucket, a server of your own, or a folder with no remote at all. No token and no list of hosts: Cody gets ready for your project by itself.
• Ask or change. Type what you need. Cody answers, or starts a task at thinQit. Questions about the repository run as read only tasks; changes run as change tasks.
• Plan, Ask first or Auto. Choose how much Cody does by itself. Plan makes a plan whose steps you can untick, and nothing changes until you run it. Ask first asks before every change on your computer. Auto edits, tests, builds and commits in the project without asking. It still asks before a push you did not ask for, a production deploy, deleting a branch, throwing away changes, a new package, anything outside the project and changes in your cloud; passwords, keys and tokens stay blocked. The modes show when your thinQit workspace offers them.
• Every new request is grilled first. Before a new change becomes a task, Cody asks a short round of clarifying questions, each with options to click (one, or several where it says so) and an Other... field for your own words. Send answers sends what you picked as your next message; Just do it skips the round and lets Cody go on with its own assumptions. With an older server the question comes as plain text and you type the answer. The round lives in the conversation host, so keep thinqitCody.hostChat on (the default).
• Short replies. While Cody works you see one live line. When it is done: the outcome in a few lines, the files, and the steps closed. One click opens the steps, one more a command with its output.
• Steps, one by one. A task runs as steps and the chat stays clean: the live line says which step Cody is on, the running step shows its commands and files, and each finished step folds to one line with its time.
• A quiet line at the bottom. Under the message box: your branch and what the newest task cost. The dots at its end open Details: the working memory, your credits and what you allowed this session. The mode, the agent and the reasoning level sit in the message box itself.
• Credits in the panel. Add credits shows your balance, Cody's use per day this month, credit packs and plans inside the panel. You pay in your browser, and the panel notices the payment by itself. Until your thinQit workspace offers this, Add credits opens the billing page of thinQit in your browser.
• Edits land in your editor. Each file Cody writes appears in your workspace as it happens. Open files change through the editor, so undo works and unsaved work stays unsaved.
• Review per file. The diff list shows every file with its line counts. Open a diff, accept a file, or revert it. Revert keeps anything you typed after Cody's edit.
• Your own browser and command line tools. Cody can read pages in its own browser beside the editor and run your signed in command line tools (gh, az, gcloud, aws, kubectl, docker and more) on your computer. Reading is free; outside Auto every change shows the exact command and waits for your Allow. Passwords, keys and tokens never leave your computer.
• Show Cody the spot. When a change is on a page, Cody's first reply offers to show where it goes in the browser: right click the spot, and Cody gets the element, where it sits in the code and a picture of it. Your message shows it as a chip, such as Element: button "Pay now". Any time, right click anywhere on a page in Cody's browser to instruct Cody about that spot.
• Attach files. Add pictures, PDFs and text files such as JSON, XML, CSV and logs to a message: the plus in the message box, a drop from your desktop or the explorer, or a pasted picture. Up to 10 files of 25 MB each; they stay private to your workspace for 30 days.
• Cody's own files. Screenshots and other files Cody makes for you show in the chat with a preview, Open and Save to workspace. They are never written into your repository unless you save them.
• ArtifaQt pages. Cody can publish a page from a task, such as a test report or an architecture document. It is private to your workspace, keeps its versions and opens in the editor or in your browser. Share it with a link you can switch off.
• Test driven. You approve the test cases first. Cody writes each test, sees it fail, then makes it pass, and shows how each case was proven.
• Images show as images. A screenshot or another image Cody saves in your workspace (png, jpg, jpeg, gif, webp, svg) has a thumbnail in its file row, and shows under the message that names it. A click opens it in the editor's image preview.
• Ship from the panel. Once you accepted a task's files, Commit and push commits exactly those files with your own git and pushes your branch. Nothing else in your working tree goes along. In Auto, each finished change task gets a commit of its own, and Cody pushes only when you ask.
• Merge conflicts. When a pull stops on merge conflicts, Cody resolves them: in Auto by itself, in Ask first after one click, in at most five rounds. Your uncommitted work is never lost.
• Typing during a task is safe. When you change a file Cody is also changing, the two are merged. When the changes overlap, Cody writes nothing and asks you to choose: take Cody's version or keep yours.
• Stop at any time. Stop ends the task within seconds. Edits made so far stay and can be reverted.
• Big or sensitive changes wait for one click. When Cody changes more files than usual, deletes or renames many files, or touches a file that may hold secrets, those edits wait at thinQit. A card in the task lists the files with "Apply these changes" and "Skip"; it still works after the task has ended.
• Project memory. Cody keeps notes on what it changed and decided, every task. The Memory tab shows them with the state of the project index; you can search, filter by kind, edit or delete any note, and add your own. A note Cody wrote guides later tasks only after you confirm it.
• Relevant files. A small index of your repository on your own computer suggests the files that matter for your message, so Cody looks there first.
• Connectors. Give Cody tools outside your repository, from MCP servers: a remote server with a token, a local server package, thinQit's own tools, or your own config files. Calls that create, send or delete wait for your Allow in the task.
• Capabilities. thinQit adds skills to Cody: slash commands such as /review and /tests, cards with results such as the last test run, ready made connectors, and tools in Cody's workspace. Standard ones are always on; optional ones you switch on in the settings.

Requirements

• A folder that is a git repository, with the git command available.
• At least one commit. Any host, or none.
• A thinQit account with thinQit Cody enabled and credits.
• VS Code 1.95 or later. Remote SSH, WSL, Dev Containers and Codespaces work: the extension runs next to your files.

Getting started

1. Open the thinQit Cody view in the activity bar and choose Sign in.
2. Allow thinQit Cody on the thinQit page in your browser. You come back to the editor signed in. If the browser cannot open the editor, copy the code from the page and choose Paste code.
3. The first time, Cody gets ready for your project. This happens once per repository; on a slow connection it takes a few minutes, and you can keep working.
4. Type a message and press Enter.

For a private GitHub repository, thinQit Cody: Set Git Token is an optional faster way: a fine grained token with read only access to Contents lets Cody fetch it directly. It is stored encrypted at thinQit and never shown again.

Commands

In the message box: /ask asks about the repository without changing files, /do starts a change right away, /new starts a fresh session and /stop stops the running task. Type / to see these and the commands of your capabilities.

Settings

Images

When a task saves an image in your workspace, for example a screenshot, its file row shows a thumbnail and Open in place of Diff (an svg keeps Diff, because it is text). When Cody's message names the file, by its path or by its file name, the image shows under that paragraph, at most 4 per message. A click opens the file in the editor's own image preview.

Only image files of that task that are in your workspace are shown. The panel never loads an image from an internet address, and an svg is shown as a picture, never as markup. An image you revert, or that Cody deletes again, leaves the chat. An image over 10 MB shows a chip to open it instead of a preview.

The status line

In the bar of the message box:

• Mode: Plan, Ask first or Auto where your thinQit workspace offers them, else Ask (read only, a question) or Change; and Test driven (see TDD mode). Shift+Tab in the message box, or thinQit Cody: Next Mode, moves to the next mode.
• Settings: the agent (Pixy, Cody or Vexy, see below) and the reasoning level (Quick, Balanced, Deep, and thinQit Ultra where the engines have it), each with Back to the default. Replies are always short. A level shows its typical credits and time only once thinQit has measured enough real tasks at it.
• Agent: next to Settings, once you picked another agent than your account's default. Arrow keys on it move between Pixy, Cody and Vexy.

The line under the box is one quiet line: the branch (its full name on hover) and, once the newest task is charged, what it cost. The mode shows in the box only. The dots at the end of the line open Details:

• the branch in full and the base commit,
• Working memory: how full it is and what fills it (the conversation, files Cody read, the project memory, tool results), what your next message does, Summarise and continue and Start fresh,
• Credits: this task, this session and your balance, with Add credits,
• Approvals: what you allowed for this session, with Revoke.

Arrow keys on a focused chip change its value. Your choices are remembered per project and travel with every message.

Agents: Pixy, Cody, Vexy

Three agents can do the work. Pick one in the Settings popover of the status line; it is remembered per project and travels with every message.

The agent and the reasoning level are two separate choices: the agent is who does the work, the level is how long it thinks. Once you picked another agent than your account's default, an agent chip stands next to Settings; arrow keys on it move between the three. For projects where you picked none, thinqitCody.agent sets the agent (auto follows your account). An agent shows its typical credits and time once thinQit has measured them. With a thinQit server that offers no agents yet, the panel shows none and sends none.

Your browser and command line tools

The first time Cody wants to use something on your computer for a project, it asks: Allow for this project or Not now. After that:

• Reading is free. Commands that only read (for example git status, gh repo view, az account show) run without asking, and Cody reads pages on your dev server in its own browser.
• Every change asks. A card shows the command exactly as it will run, why Cody wants it, and the folder, with Allow once, Allow for this session and Do not allow. Destructive commands (a delete, a reset, terraform apply) ask every time. Any other local address than your dev server asks before Cody reads it, and running script in a page always asks with the full script shown. In Auto, a change with the project's own tools runs without a card when nothing risky is found; Plan runs no change at all.
• Never. Shells, inline code, more rights, secret stores, environment dumps, credential files, secrets on the command line and options that make a command launch another program are refused.
• Right click to ask. Right click anywhere on the page in Cody's browser and a small box opens at that spot: type what Cody should do there and press Send (Ctrl+Enter), or Cancel (Esc). Cody gets your words with the page's title and address, the element under the click (a short selector, its tag), a screenshot with the spot marked, and the element's HTML (up to 8 KB), as one chat message marked From the browser. Switch it off with thinqitCody.browser.pickPrompt; a right click then goes to the page.
• The visual editor. Where your thinQit workspace offers it, "Right click anywhere to instruct Cody." stands under the toolbar (thinqitCody.browser.pickHint hides it), and Pick an element on the toolbar works with a click. The box names the element (Wider and Back move to its parent and back), Cody also gets where it sits in the code, and your message shows it as a chip such as Element: button "Pay now". When Cody's first reply offers to show where a change goes, Cody's browser opens your page and waits for your right click. After the task your dev server's page shows the change with the element outlined; on a deployed site you see it after the next deploy.
• Cody needs you. When a page needs you (a sign in, a captcha, a sandbox payment), a card asks you to do it in Cody's browser beside the editor and press Continue.
• Dev server. Cody can start your project's dev, start, serve or develop script after you allow it; the card shows what the script runs. It stops when the task ends.

Commands run without a shell, in a folder inside your project, with your own sign ins. Output is scrubbed of secrets before Cody sees it. Cody's browser has its own profile, never yours; its cookies and storage stay on your computer. Details at the end of the line under the message box shows what you allowed for this session, with Revoke. Files that make the editor run programs (.vscode/tasks.json, .vscode/launch.json, workspace files) are never written without your click.

Attachments

Add files to the next message with the plus in the message box, by dropping them on it (from your desktop or the explorer), or by pasting a picture. Allowed: pictures (png, jpg, gif, webp), PDF, and text files (json, xml, csv, yaml, md, txt, log, html), at most 25 MB each and 10 per message. Each file shows as a chip with its upload progress; Send waits until every file is through. A file that is refused says why under its chip: the wrong type (also a file whose content is not what its name says), too large, empty, one too many, or a file that seems to hold a password or a key.

After sending, the chips stay under your message. A click opens the file; the bin deletes it from thinQit. Files are kept 30 days and are private to your workspace; thinQit never makes a public link to them.

Cody's own files

When Cody makes something for you, such as a screenshot of your app or a test log, it shows in the chat: a picture as a card with a preview, other files as a chip, each with Open and Save to workspace. Nothing lands in your repository unless you save it. They come back after a reload and are kept 30 days.

ArtifaQt

An ArtifaQt is a page Cody publishes from a task: a test report, a UI check, an architecture document or another document. thinQit hosts it, private to your workspace: only signed in members can open it.

Ask Cody to make a page of what it did or found. A run in TDD mode publishes its report by itself.

The task ends with a card: the title, the kind, the version and a summary.

• Open in editor shows the page in an editor tab. Its scripts run in a sandbox that loads nothing from outside. A link in the page opens only after your click and a second click on Open in browser at the bottom of the tab.
• Open in browser opens the page on thinQit, signed in.
• Versions. A later task that changes the page adds a version. Pick any version on the card. When nothing changed, the card says so.
• Share. Switch it on for a link anyone can open without signing in, and Copy link. The link shows the version that was newest when you switched sharing on, and later ones; older versions stay private. Switch it off and the link stops working at once.
• While Cody is still publishing the page, the card says so and updates by itself.

The ArtifaQts tab, or thinQit Cody: Open ArtifaQts, lists the project's pages, newest first, with the same buttons and Delete. ArtifaQt shows as soon as your thinQit workspace offers it.

TDD mode

In TDD mode you and Cody agree on the test cases before any code changes. Cody then writes each test, sees it fail, and makes it pass.

Pick Test driven in the Mode chip of the status line, type /tdd and, if you like, your goal, or run thinQit Cody: Toggle TDD. Without the status line, use the TDD button next to the message box. A form opens: the goal, then one line per case with what should happen and its kind (Unit, Integration or UI). Write the cases yourself, or press Draft cases and check what Cody drafts. A run holds at most 20 cases. Nothing runs until you press Approve and start.

While Cody works, a checklist in the task shows each case: Planned, Seen failing, Seen passing, Observed in the browser, Failed or Not verified. The test runs fold under it, each with its command, exit code and counts. At the end:

• A case passes only when a test run or a check in the browser proved it, and its line says which.
• A UI case checked in your browser shows its screenshot. A click opens it in the editor.
• A case that was not checked before the task ended shows as Not verified, never as passed.
• One summary line, such as "TDD: 7 of 8 cases passed, 1 not verified.", and the report as an ArtifaQt card under the checklist.

TDD mode shows as soon as your thinQit workspace offers it.

Ship: commit, push and deliver

Outside Auto, Cody never commits, pushes or deploys by itself: your own git and sign ins do, after your click. Three ways in, one form:

• Commit and push under a task whose files you decided, or the command thinQit Cody: Commit and Push.
• Cody proposes it when you ask it to commit, push, ship or deploy (in your own words or with /ship): the same form opens filled in with Cody's message and files, and you can change both.
• Single git or delivery commands Cody runs through your command line tools, each approved like any other change.

The form shows the subject and an optional body, the files (the accepted ones checked; other changes unchecked; files you have not decided yet listed apart), the branch and where the push goes, and the commands exactly as they will run. Those commands run one after the other, each as one line you can open for its output. When the push is refused because the remote moved, the same click brings the newer work in first: your other changes are set aside, the newer work is pulled, your changes go back, and the push runs again. It never forces a push, never amends a commit and never skips your hooks.

When bringing the newer work in needs you (the same lines changed on both sides, history rewritten on the remote, or a merge or rebase still in progress), the form says so in one sentence and offers the commands to run, never a force push. Where your thinQit workspace offers it, Cody resolves merge conflicts itself (see Merge conflicts). A repository without a pull setting rebases, unless that would flatten a merge of yours. When the branch takes pull requests only, the commit goes to a new branch and the pull request opens (GitHub, Azure DevOps, GitLab and Bitbucket).

In Auto. Each change task that ends in Auto gets a commit of its own: exactly that task's files, never a file that may hold a password or key. One line in the chat names it, with Undo the commit. Cody pushes only when you ask, and a push to the default branch asks once per session. Cody sorts out a branch that takes pull requests only, a branch name already taken or newer work on the remote by itself, never with a forced push.

When the project has git hooks, Auto lists them once per session before its first commit or push: each hook and the commands it runs, also the ones that came with the repository, with Run them in Auto. Until you click it, Auto commits and pushes nothing, and Cody's own git commands that run hooks (a commit, merge, pull, rebase, switch or checkout) wait as well. The confirmed hooks show under Details, in Approvals, with Revoke; a hook that changes or comes new asks again.

Delivery. Cody learns how your project is delivered from a cody.deploy block in your instructions file, your workflow files or your deploy scripts. After a push the editor watches the pipeline (with gh for GitHub) for up to an hour and tells you in the chat when it passed or failed; on a failure Ask Cody to look at it starts a task with the failed jobs' last lines.

Switch the button off with thinqitCody.ship.enabled.

Merge conflicts

When a pull, or Ship bringing in newer work, stops on merge conflicts, a card above the message box names the files and takes the conflict to the end. It shows as soon as your thinQit workspace offers it. thinQit Cody: Resolve Conflicts opens it for a merge or rebase that is already stopped in your repository.

• Ask first: one click. Let Cody resolve them, or I will do it myself. In Plan the card works as in Ask first.
• Auto: by itself. The card says "Cody is resolving them." and has Stop. The git hooks line of Auto (see Ship) comes first.
• The round. Cody makes the pull again as it stopped, with your uncommitted changes set aside, then runs a task that resolves the conflicts in those files. The chip under your line says the round, for example Round 1 of 5.
• The check. After the task the editor reads the files itself. A file that still has conflict markers is named, with Let Cody try again, I will do it myself and Abort the pull. When all are resolved, the card shows the next commands exactly as they will run: the files added, the rebase continued or the merge committed, your changes back, and the push when you asked for one.
• Continue. In Ask first one click: Continue and push, or Continue when you asked for no push. In Auto at once, after the project's own tests pass (at most 10 minutes). When the tests fail, or Cody finds none, it stops before the push and says so.
• A push that needs you. A push the safety rules hold (it delivers, goes to the default branch or goes to another address) is never part of Continue: the pull is finished first, and the push waits on the card with Push or Close.
• Five rounds at most. A rebase that stops again on its next commit is the next round. After five, Cody stops and you finish or abort the pull in your own tools.
• Your work is safe. Changes that do not go back cleanly get a round of their own and also stay in the stash, named, until you choose Drop it. Abort the pull first keeps your other changes in a stash entry of their own, "Cody: before abort".

Cody never forces a push, never changes your git configuration and never drops a stash entry you did not drop.

Connectors

Connectors give Cody tools outside your repository, from servers that speak MCP (the Model Context Protocol). They belong to your thinQit workspace, so they work in every project and every editor you sign in with, unless you limit a connector to one project. Open the Connectors tab (or thinQit Cody: Open Connectors) to add, edit, switch off, test or delete them; thinQit's Settings has the same list.

Ask before changes. Every connector has this switch, on by default. A tool that creates, sends or deletes something then waits in the task: a card shows the connector, the tool and its arguments (secrets removed), with Allow and Skip. Skip tells Cody you did not allow the call. Reading never asks. The task waits up to 10 minutes for your answer. Under "Which tools ask" you can name tools that should always ask or never ask.

Test connects once and lists the server's tools, with what each one does in a task: reads, asks first, or runs without asking. For a local server the test checks the allow list; its tools are listed when a task starts it.

Secrets are write only. Header values, variable values and config files are sent to thinQit once when you save, stored encrypted, and never shown again: the list shows header and variable names and the last 4 characters of a value. Leave a value empty when you edit to keep it.

Honest limits.

• Connectors you added to an AI assistant's own website or desktop app belong to that sign in, so Cody cannot use them. Cody keeps its own connectors: add them here.
• Servers in your own config files act without asking: Cody cannot ask you before they change something. You are responsible for what they start.
• A .mcp.json file at the root of the repository is used as well. Its servers are not in the list and act without asking.

Capabilities

Capabilities are what thinQit adds to Cody, released with thinQit itself: no update of the extension is needed for a new one, unless it says it needs a newer version. The extension asks thinQit for the list when the project is ready and again every 10 minutes.

Standard and optional. Open the settings (the gear in the panel) to see the Capabilities section. Standard capabilities are always on. Optional ones have a switch and show their price per use, in credits; some cost nothing and are still counted. Your administrator can switch a capability on or off for the whole workspace; it then has no switch here. When a capability needs something you do not have yet (a connector, an engine, a newer extension), the section says what, and offers Add connector when a preset fits.

Commands with arguments. Pick a command from the / menu and a small form opens above the message box: a text, a file (type the path or choose it with Choose) or a choice from a list. What you type below the form is added to the command. You can also type the whole line, for example /tests lib/naming.ts only the edge cases: values fill the arguments in order, name=value sets one by name, and the rest is extra text. When a required argument is missing, the form opens. A command always starts a task in its own mode (a question or a change); the line you typed shows in the chat.

Cards. The Cards tab appears when a capability that is on has cards. Each card has its own Refresh; while the tab is open, cards refresh on their own interval, and after each task. An item can open a file of the repository or an https page.

Connector presets. A preset fills in the server and which tools ask first; you fill in its token or variable fields. Values are write only, like every connector secret: sent to thinQit once and never shown again. A token field may add Bearer in front of what you paste.

Tools that ask first. A capability tool that asks first waits in the task like a connector call: a card shows the capability, the tool and its arguments (secrets removed), with Allow and Skip. The task waits up to 10 minutes.

Memory notes Cody writes. Only notes you wrote and notes you confirmed guide later tasks. Each note Cody wrote has Confirm; a confirmed note shows Confirmed and has Remove confirmation.

What is sent, and what is never sent

Before every task the extension brings Cody up to date with your local changes, so Cody works on exactly what you see. What leaves your computer:

• the commit your work is based on (the last commit you pushed, or where your branch left the remote default branch),
• every change since that commit: unpushed commits, staged and unstaged changes, new files that git does not ignore, and unsaved editor buffers,
• nothing when nothing changed since the task before.

Files in .gitignore never leave your computer. Your local changes are limited to 20 MB and 2,000 changed files; new files over 1 MB are skipped. When your changes are larger, the panel asks you to commit and push first.

With each message the extension sends context: the path of the active file, the visible lines, your selection (at most 16 KB, never from a secrets file or a file your exclude setting covers), the paths of open files (at most 20), up to 50 problems, the last three terminal commands with their output (at most 8 KB), the branch name, and the paths of up to 8 relevant files with a score. File contents are not sent as context.

Relevant files. At the first message the extension builds a small word index of the files git tracks (no file over 256 KB, no binaries, lockfiles, minified bundles, node_modules, dist, build or .next, and never a secrets file or a file your exclude setting covers). It stays on your computer, in the editor's storage for the extension, and only the paths it ranks are sent. Switch it off with thinqitCody.context.relevantFiles.

Never sent. Files that usually hold secrets are withheld and never written by Cody without your click: .env files (except .env.example, .env.sample and .env.template), keys and certificates (*.pem, *.key, *.p12, *.pfx, *.jks, *.keystore, id_rsa*, id_ed25519*), credential files (.npmrc, .pypirc, .netrc, .git-credentials, .aws/, .ssh/, .docker/config.json, credentials.json, service-account*.json, secrets.json and similar data files), Terraform state and variables, and anything matching thinqitCody.sync.exclude. A changed file that contains something that looks like a key or token (cloud keys, Git tokens, model API keys, Slack and Stripe keys, private keys, long JWTs, thinQit tokens, or a password assignment) is withheld as well, and the panel tells you which file. In your selection, terminal output and problem messages such values are replaced with [redacted].

Limit of the filter. Secrets that are already committed to your repository are part of what Cody works on. Remove them from the history if they must not be there.

How credits work

Each task is charged in thinQit credits by the tokens the coding engine used. An optional capability adds its own price per use (per task, per command or per tool call), shown next to its switch. When a task starts, thinQit holds a small amount of credits; when it ends, you pay what the task used and the rest of the hold comes back. A task that failed on thinQit's side and changed nothing costs nothing. A task you stop, or that reaches its credit limit, costs what it used. The panel shows the credits left and the credits charged at the end of each task; while a task runs, nothing is charged yet. Conversation replies that do not start a task are not charged.

Engines

Cody can run a task on two coding engines and picks one for every task by itself; there is nothing to choose. When the engine fails, stalls or hits a limit, the other one takes over once and the task card says so.

Privacy

• The extension talks only to the thinQit address in thinqitCody.server. It sends no telemetry.
• Your sign in token is kept in the editor's secret storage and can be revoked in thinQit under Settings, Integrations, VS Code, or with Sign Out.
• Connector secrets you type in the panel go to thinQit when you save and are not kept by the extension.
• Attachments and Cody's own files are stored by thinQit, private to your workspace, for 30 days, and are only served through your signed in editor; a file you delete is gone at once.
• ArtifaQt pages are stored by thinQit and private to your workspace. Only a share link you switch on shows one outside it, and switching it off ends that link at once. Open in editor loads nothing from outside.
• When Cody cannot reach your repository from its remote, your editor gives Cody the tracked files of the commit you are on, committed secrets included, and after that only what a new commit changed. Never an untracked or ignored file, never the objects of the history. The commit log goes along as names, dates, messages and file names, without e-mail addresses and without diffs.
• Review state (the originals needed for Revert) stays on your computer in the extension's workspace storage and is removed when every file is accepted or reverted, or after 7 days.

Support

Questions and problems: thinqit.io/support. Please include the output of thinQit Cody: Show Task Log; it holds no file contents and no tokens.