What’s new in Jinion

• The terminal app shows one view at a time from a strip at its top, with commands by / and a ctrl+k palette, and conversations switched with ctrl+t.
• Terminals the agent opened close once their command ended and its turn is over, unless you typed in them; a dev server it started stays, isn't started twice, and the agent can stop what it no longer needs.
• The terminal app's editor colors a file on a thread of its own, so typing in a long file no longer stalls, and files up to 2 MB are colored.
• The terminal app's Changes view: the thread's files beside their diffs, stacked, unified or split, with staging, discarding, committing and undoing a turn from its keys.
• The terminal app's editor shows what the language servers find: problems underlined and said after their line, alt+n to the next, alt+d to a definition, alt+i for what the code is, and who last changed the cursor's line.
• The terminal app's Code view wraps long lines on alt+z, narrows a search to chosen files, replaces in one file, and compares a file that changed on disk with your edits; cmd works as ctrl where the terminal passes it on, and the Git view can undo any operation in its list.
• The terminal app's Code view: the project's files and a search beside an editor with tabs, selection, undo, find and saving.
• The terminal app's Git view: one list of proposed commits and history to drill into, repositories, branches and stashes behind a key, and conflicts settled in three columns.
• The terminal app's Code view opens a file in your own editor on alt+e, at the cursor's line, and takes in what you saved there.
• Scrolling no longer flickers: each frame writes over the screen rather than blanking its rows first, and the view no longer jumps and comes back as the agent's work grows above it.
• The terminal app's Tasks view: what runs in the background, one row each with its last line, opening to all of its output.
• The terminal app paints the whole screen in the desktop's themes, picked with /theme; a pick in one app shows in the other.
• The terminal app draws a conversation as turns: a header row with how the turn goes, its steps one line each down a gutter, and questions in the composer's place.
• The context's share is measured against the model's real window from the moment a conversation picks up again, and after a model change, so a 1M-token model no longer reads as over 200% full.
• A decision recorded about a folder reaches the team once a commit changes a file in it, instead of staying "not in a commit yet" until it is deleted.
• Git is followed rather than read every few seconds: nothing runs while nothing changes, an edit shows within a moment, and only the files that moved are sent. Repositories nested in another, submodules and worktrees show beside the others, and a repository with thousands of changes shows its branch again.
• Tables in an answer fit the conversation's width, their rules no longer wrapping onto lines of their own, and a table with more columns than the width holds is drawn a row at a time.

• Threads can be archived to take them out of the lists without losing them, then restored or deleted for good: from a thread's row, ⇧⌘A and Settings › Archived threads in the desktop app, and with /archive, ctrl+x in /resume and /archived in the terminal.
• jinion mcp gives Codex, Claude Code, Cursor or any agent that takes an MCP server your team's decisions for the commit you're on and the project map, and records a decision when you ask it to. Signing in is a link to approve on cloud.jinion.co, and a workspace invite is enough to use it. find_decisions now names the commit a decision is in, and lists the ones not pulled yet apart.
• An answer you haven't seen stays marked until you look at it, as in a chat app: an accent dot and a bold title in the thread list, a dot on the project's square in the rail with "2 new replies" in its note, and a count on the Dock's icon of the threads that wait on you or have an answer unread. Clicking a notification opens its project and thread. The marks are kept with each conversation, so they stay after a restart.

• While the agent draws directions, you see each one arrive: it builds them a page at a time, and with Claude the working line says which page it is writing and how far it got, such as Building the "Ledger" page · 18 KB, as it does for a long file it writes. Thinking folds as soon as the agent moves on to writing, rather than staying open over minutes of work.

• On Claude, Full access no longer asks about anything, and Auto stops asking about commands that only read, such as sed -n, grep and head, also after switching from Accept edits or Debug in the middle of a conversation. Accept edits and Debug still ask before removing, moving or overwriting files, and sed only when it edits a file in place.

• Agents keep to the team's decisions that bind their work: they are told them nearest to the work first, look them up with find_decisions, name the teammate whose decision they kept to, ask before going against one and supersede it once told to, and review_turn names a change that goes against one and warns of a teammate's decision on another branch that touches the same files.
• In a project linked to a team, agents on Claude and Codex record the decisions that matter with record_decision, each shown in the conversation and deletable by its author; Jinion keeps a copy of the project's decisions on the machine, sends what was recorded offline once it can, and deletes the copy when the user loses access.
• Each session sorts the project's decisions by what the HEAD of its folder has: binding once a commit it has carries one, waiting to be pulled, on another branch, or dropped; a draft anchors itself to the commit that carries it, made in Jinion or in the user's own terminal.
• A conversation open in the terminal can be taken over from another Jinion, such as the desktop app: its turn stops where it is, it is saved, and it goes on there.
• Team decisions show in both apps: each one the agent recorded is a line in its turn that opens to what, why and what was turned down, beside one it kept to and a teammate's on another branch that the turn's files meet. /decisions and the desktop's Decisions page group them as your branch sees them (in your code, not pulled yet, on other branches, yours not committed yet); /link and the same page link a repository to a team or ask to join one, and the status line and title bar say which team the repository belongs to.
• Jinion reads a repository's jinion.config.json and knows whether its user is in the team's workspace, waiting for access, or out; clients link a repository to a project and ask for access through the API.

• Full access, a mode that asks nothing: the agent edits, runs any command, commits, pushes and changes files outside the project without waiting for you, and makes the calls it can itself, saying in its report which ones it made. The first time you pick it, Jinion says what it lets the agent do and asks you to turn it on. shift+tab never lands on it; pick it from the mode menu or with /mode full. On Claude it is Claude Code's bypass permissions mode, on Codex its full access with no sandbox.

• Better looks where your project has none yet: before drawing a new look, Jinion looks at how strong products do it and tells you what it took from them, then draws each direction as a real page with care for type, spacing, color and every state, never as a description alone.
• Directions you can see and pick: when Jinion offers you directions for a look, it shows each as a real page in a viewer of its own, at an address on your machine, with the rounds of the project beside it. Pick one there and Jinion gets it as your answer. Nothing is written in your project until you pick.
• Add an MCP server from /mcp with a, by the command that starts it or its address, and remove one you added with d; one added elsewhere says where to remove it.
• Sign out of an MCP server Jinion signed in to, or sign in to it again with another account: o and l in the terminal's /mcp, Sign out and Sign in again on the desktop's MCP page.
• The agent checks what a turn wrote against the project map before its report, and writes one short report instead of two; the row reads "Checked against the project · 2 things, 1 fixed" and opens to each point in plain words.
• /skill has the agent write a skill from what you describe: it drafts the name, when to use it and its steps, asks whether it is for this project or all of yours, and writes it with a tool of Jinion's own.

• Bring your setup from Claude Code: onboarding's last step shows what already works in Jinion (Claude Code's login, skills, plugins, MCP servers), brings your notes in with one key or button, and says what stays behind. If you went through onboarding before, it shows once at your next start. A project with Claude Code notes offers them the first time it opens after that: in the terminal's banner, and on a new thread in the desktop app. The API gains setup/claude, memory/import and setup/claude-done.
• The CLI updates itself. While it is open it looks for a newer version a little after it starts and every four hours, installs it in the background into ~/.jinion/versions without sudo and without touching the version running, and says ready · restart to update on the right of the status line; the next jinion runs it. Turn it off with "autoUpdates": false in ~/.jinion/settings.json or JINION_DISABLE_AUTOUPDATER=1.
• See what Jinion read from your project, which the agent works from: what it is built with, how its code is written, how it looks and what its files offer each other. /map in the terminal, with a line of it in the banner; in the desktop app, a Project map page and a card on a new thread. Where the project's linter has no rule for a habit, Add the rules asks the agent to add them.
• See what's new after an update. The desktop app opens What's new on the first start on a new version, with every version since the one you had, and keeps it in the account menu. The terminal says once in the banner that Jinion was updated, and /release-notes shows every version.

• Rate an answer and tell us what went wrong: the thumbs under an answer in the desktop app, /feedback in the CLI, with the conversation sent along only when you choose to.
• Set how long the agent's answers run: Brief, Balanced or Detailed, from the next message and in every project. In the terminal with /answers, in the desktop app under Settings, Personalization.
• The agent explains at the level you show: short and technical when you are, plainer when you describe what you see, and step by step, with what each step does and what you'll see, when you say you don't follow.
• Debug mode, the agent that finds why something fails. It traces the problem through the code, adds diagnostics that write to an evidence log Jinion keeps for the conversation, makes the problem happen or asks you to, and reports the path, the evidence, the cause and what is still open before it fixes anything. /debug <problem> starts it, and shift+tab and /mode reach it too, on Claude and on Codex.
• Edit a message before it goes: up in an empty prompt takes back the steered messages the agent hasn't read yet, and the queued ones, so the agent no longer gets them. enter steers with them again, or puts them back in the queue when they were all queued, or sends them if the turn has ended meanwhile. A steered message comes back with Claude, not Codex.
• Jinion now asks you to sign in before you start, with GitHub or with a 6-digit code sent to your email. You stay signed in on your machine, also without a connection. See your account or sign out with /profile in the terminal, or under Settings, Profile in the desktop app.
• On a Mac, the prompt deletes a word with option+backspace and the line with cmd+backspace, and in Terminal.app Jinion offers once to turn on Use Option as Meta key, which those keys need there; /terminal-setup does it any time. /mcp signs in to Linear and Notion through their own servers, and no longer lists claude.ai connectors it can't sign in to.
• Jinion is invite-only during the beta: after signing in, a new account enters its invite code and answers a few questions before Jinion opens, in the terminal and in the desktop app. Fast typing no longer drops keys in the prompt.
• The spinner beside a running command or task no longer jumps in terminals whose font joins [|] into one glyph, such as JetBrains Mono with ligatures on: its upright frame is now │.
• During the beta, Jinion sends how each turn went (how long it took, which model, whether it failed) and the errors it hits, never your prompts, replies or code. Turn it off with /telemetry off, or under Settings, Profile, Telemetry in the desktop app.
• What the Jinion team has to say shows on a new thread in the desktop app, until you dismiss it, and once under the banner in the terminal.
• Each beta user has three invite codes to hand on, each letting one person in: under Settings, Profile in the desktop app, and in /profile in the terminal, with who joined with the ones used.

Sign in to MCP servers such as Linear and Notion without leaving Jinion.

• In /mcp, a server that shows not signed in gets l: press it and finish in the browser. If the browser doesn't open, the link is shown to open by hand, and Esc gives up.
• With Claude, Jinion keeps the sign-in in ~/.jinion/mcp-logins.json, readable only by you, and renews it before it runs out, so a turn never stops halfway on an expired one. With Codex, Codex keeps it.
• The server connects from the next turn.

Any file goes with a message, not only pictures, and the agent understands the recordings and videos among them.

• Drag a file into the terminal and it is attached: it shows in the prompt as [File #1 report.pdf]. A file of the project stays its path, as before, unless it is a recording, a video, a PDF or a spreadsheet, which is read for the agent first.
• A file is kept in a folder of the conversation under ~/.jinion/attachments, out of your project. The agent is told where each one is and reads it with its own tools. An Excel workbook also gets its sheets as CSV and a PDF its text, so Codex reads them too.
• A recording is transcribed on your machine with Whisper, in about a hundred languages, each piece with its time; nothing of it leaves the machine. The speech model, 574 MB, is downloaded the first time you attach a recording.
• A video becomes what is said in it and its frames, one each time the picture changes, such as a page opening or text being typed, so the agent can follow a screen recording step by step.
• While a file is read, reading: … above the prompt says what is being done, and a message sent before it ends comes back to send again. A file that can't be read is attached as it is, and the conversation says why.
• Recordings and videos are read with the ffmpeg, ffprobe and whisper-cli on your PATH.
• For clients of the API: attachments/add and attachments/remove, the session's attachments field, the ids a message names in attachments, and files/read and files/read-bytes for a session's attachments.

Jinion works on an interface as a design engineer, from a map of your project that it reads from the code and keeps up to date by itself.

• The map holds what the project's files offer each other (components, hooks, functions, classes, types, constants, design tokens and styles), how the project is written (how files are named, interface or type, named or default exports), what it is built with, and how it looks: its tokens, the classes and style values its interface keeps to, the colors written outside both. It reads JavaScript and TypeScript, Vue, Svelte and Astro components, React Native style objects, Swift and SwiftUI, PHP and Blade, stylesheets and templates, and a file is read again only when it changed. A conversation in a worktree reads the map of its own folder.
• The agent looks for a piece that already does the job before it writes a new one, and writes what it adds the way the project is written.
• On an interface it builds from the project's own components, tokens and classes, says what it understood before a new screen, and offers named directions to pick from where the project hasn't decided, such as the first screen of a new project. A pick is saved to its notes and applied from then on.
• It looks at what it made: it takes a picture of a page with Chrome, Chromium, Edge or Brave on your machine, run without a window, or of the iOS simulator's or the Android emulator's screen, at the width and in the color scheme it wants to check.
• What a turn added is compared with the map before the turn is over: a piece the project already had, a file named against the project's habit, a class or a color new to it. The agent puts it right, or tells you what is new and why; what you asked for by name stays as you asked.
• Where your linter, Biome or ESLint, has no rule for one of the project's habits, the agent can offer to add the rule, by its exact name.
• With "describeMap": true in ~/.jinion/settings.json, the small model writes a sentence on what each piece does, so one is found by what it does and not only by its name, and a new piece that does the job of one under another name is caught as the turn ends. It is off by default, since it spends your plan's usage.

• A folder with thousands of changed files no longer freezes the changes: the lines changed are counted in the background, and again only once a file changes.

• Open conversations move from the row of tabs above the conversation to a column on the left, one per row, with a spinner while one works and ? while it waits on you. A click anywhere on a row goes to it. In a terminal narrower than 100 columns the column keeps only each number and mark, and ctrl+s hides it and shows it again.
• A message sent while the agent works waits above the prompt until the agent reads it, as soon as its current step is done, and then joins the conversation at that point. Before, it showed in the conversation at once, so it was hard to tell when the agent picked it up. Works with Claude and Codex.

• Code in color, by its language: the diffs of edits and writes, the /diff panel and the code blocks in replies. The diff keeps its added and removed backgrounds and the mark on what changed in a line.

• The core starts from @jinion/core/host, takes clients over a message channel (portTransport), and reads a file in a session's folder with files/read, all for the desktop app. The CLI works as before.

The first version of Jinion, a coding agent for the terminal.

• Works with Claude, signed in with a claude.ai subscription, and with Codex, signed in with ChatGPT. /model lists both; picking a model of the other hands the conversation over.
• Four permission modes: Manual, Accept edits, Plan and Auto, where a safety check stops actions beyond the request.
• Conversations in tabs, resumed with /resume, rewound to any message with the files put back, and each in a git worktree of its own when worktrees are on.
• /diff and a card of what each turn changed, background tasks, subagents shown under the call that started them.
• Memory that carries over between conversations, project instructions, skills and MCP servers.
• /usage, /stats, /context and /compact, a status line built from segments, notifications when a turn ends.
• jinion serve runs the core without a screen, on a WebSocket or over stdio, and jinion --attach shows its conversations.

• Builder: give Jinion a Claude artifact or a site and it reads it as a browser shows it, and takes a site's pictures into your product. The message box stays open and keeps the keys while you hold ⌘ or click inside it, starts a new line with ⌥↩, takes a pasted picture and sends files without any words. A choice Jinion made opens a menu of what else it could be, and a round of looks can be answered in words: none of them, one with a change, or two together. A phone shows your product as an iPhone does, with its status bar, at its real shape whatever the window's size. The sitemap opens to move around with its links shown, has a way back on its toolbar, zooms to the place you double-click and glides on when thrown.

• Builder: describe a website and Jinion makes it while you watch, keeping each change as a version you can go back to, a sitemap of every page, and choices you can change with a click. When it needs to keep data or go online, it asks to connect your own Supabase and Vercel accounts, and puts your site online for everyone.
• Terminals the agent opened close once their command ended and its turn is over, unless you typed in them; a dev server it started stays, isn't started twice, and the agent can stop what it no longer needs.
• The terminal app paints the whole screen in the desktop's themes, picked with /theme; a pick in one app shows in the other.
• The context's share is measured against the model's real window from the moment a conversation picks up again, and after a model change, so a 1M-token model no longer reads as over 200% full.
• A decision recorded about a folder reaches the team once a commit changes a file in it, instead of staying "not in a commit yet" until it is deleted.
• Git has a mode of its own in the desktop app. Every repository of the folder sits in the sidebar, nested ones and submodules included. What waits to be committed comes first, grouped by the thread that changed it, with the history and its branches under it. Jinion plans the commits: you change the split by telling it, move a file or leave lines out, and nothing is committed until you say. Branches switch from ⇧⌘B and read like a commit. A pull that has gone apart asks whether to rebase or merge. A push after a rebase says it replaces commits. A merge or rebase warns of coming conflicts, and a conflicted file opens in three columns, which Jinion can resolve for you to check. Stash, revert, copying a commit to a branch and moving a branch are a right-click away. Every git operation can be undone, from the note after it, ⌘Z, or the log of what was run.
• The history names the pull request behind each merge, squash and rebase merges too, once the project's GitHub App is connected. A file's or a folder's right-click menu opens its history in Git mode, and Git mode says when git isn't installed rather than showing an empty folder.
• Git is followed rather than read every few seconds: nothing runs while nothing changes, an edit shows within a moment, and only the files that moved are sent. Repositories nested in another, submodules and worktrees show beside the others, and a repository with thousands of changes shows its branch again.
• A tab dragged over the Preview is drawn over it, with where it would land, instead of going under the page.

• Settings has an Appearance page: System, Light or Dark, a theme from Jinion's own (Jinion, Navy, Ocean, Plum, Clay and Graphite, each with a dark side), its accent, background and foreground, the fonts and, under Advanced, the text sizes and reduced motion. A theme can be copied and pasted into another Jinion. Beside the settings, the window drawn in the theme, or in the one you point at before you pick it. The editor, code and the terminal follow light and dark.
• Threads can be archived to take them out of the lists without losing them, then restored or deleted for good: from a thread's row, ⇧⌘A and Settings › Archived threads in the desktop app, and with /archive, ctrl+x in /resume and /archived in the terminal.
• A project can have its own icon, emoji or picture and a color, set from its square's right-click menu with Change icon…; the project shown now lifts off the window's chrome rather than filling black.
• An answer you haven't seen stays marked until you look at it, as in a chat app: an accent dot and a bold title in the thread list, a dot on the project's square in the rail with "2 new replies" in its note, and a count on the Dock's icon of the threads that wait on you or have an answer unread. Clicking a notification opens its project and thread. The marks are kept with each conversation, so they stay after a restart.
• Appearance lists the color themes VS Code, Cursor, Windsurf or VSCodium have installed, and finds more on Open VSX to install; a VS Code theme colors the whole window, code in the editor, diffs and the conversation, and the terminal.
• jinion mcp gives Codex, Claude Code, Cursor or any agent that takes an MCP server your team's decisions for the commit you're on and the project map, and records a decision when you ask it to. Signing in is a link to approve on cloud.jinion.co, and a workspace invite is enough to use it. find_decisions now names the commit a decision is in, and lists the ones not pulled yet apart.
• Outside the conversation, what is at work turns as a thin ring rather than the terminal's ASCII spinner: a running thread in the list and the rail, a commit or a sync, search, the Preview's address and the settings pages. The conversation keeps its spinner.
• With no project open, the window is a quiet welcome: Jinion's mark, the projects you opened, and Open folder; the rail shows once a project is open.
• The app takes the [x] logo: its icon follows the Mac's light or dark look in the Dock, and the Welcome screen lights the [x] in squares under a lamp whose color turns through the project hues.

• In full screen, where macOS hides the window's buttons, the title bar no longer keeps their empty room at its left.
• The open projects sit in a rail down the window's left, each with a mark when a thread there works or waits for you; hovering one says what waits, ⌥⌘1 to ⌥⌘9 go to them, and + opens another.

• The context meter under the composer shows only once the context is 70% full, labelled Context, rather than a ring and a percentage that read as the work's progress.
• The answer a turn ends on says how long the agent worked on it, as Finished in 6m 12s, beside its copy and rating buttons.
• Once a turn is over, none of its todos spins anymore: what is left undone stays over the composer as not started, so a thread that finished no longer looks like it is still at work.

• While the agent draws directions, you see each one arrive: it builds them a page at a time, and with Claude the working line says which page it is writing and how far it got, such as Building the "Ledger" page · 18 KB, as it does for a long file it writes. Thinking folds as soon as the agent moves on to writing, rather than staying open over minutes of work.
• Menus, popovers, tooltips and dialogs tell the Preview when they lie over it, so it gives way to them every time and comes back live once they close, whatever else the window draws.
• The Preview stays live once a file was opened in Code mode, and menus open over it again, rather than it freezing as a picture with the Layout menu under it.
• The agent's thinking inks in word by word as it streams, as its answer does, and the boxes of commands and edits keep their whole edge while the agent works.

• The title bar shows the branch the thread works on beside the project, and the team the repository is linked to moved to the foot of the threads' sidebar.
• In the composer, pictures, files and what you pick on a page sit in the text as pills, a picture's thumbnail or a file's icon before a blue name, and move as one: the arrows step over them, a click lands at their edge, and Backspace or Delete takes them whole. The model and effort menu shows names only, about half as wide.
• The desktop's conversation moves as the agent works: what arrives opens its height and what is under it glides down, thinking folds smoothly, and words ink in as they are written. It follows the end of the conversation rather than pinning your message to the top, under a soft fade at its top edge. Over the composer, the todos, subagents at work and messages typed during a turn stack in one box, and a message sent while the agent works can be edited or removed until Claude reads it.
• A request to run a long command stays in its box, with the offer to always allow it cut to one line; a long message folds under "Show more" without losing its edges; an MCP tool's answer with no titles, such as Linear's cycles, shows as rows named by their dates, and other JSON indented; and the lines a change added and removed group their thousands, as +7,245.
• The Preview in a thread's right column can be dragged wide, leaving the conversation a fifth of the window, and stays a live page you can scroll and click: it no longer turns into a still picture of itself, follows its column as it opens and closes, and shows its page without a resize. The Layout menu opens over it. After a reload, the sidebar and panels take their place without sliding.

• In the desktop's conversation, calls of one kind in a row fold into one line, such as "Read 4 files" with their names under it, and each call shows what it found rather than what it gave the agent: a search its files and line numbers, a web search its sites, a fetched page its title, an MCP tool's list as rows, with Linear's calls said in words. Looking at a page that can't be drawn now shows as a failed call, with why.
• In the conversation, a click on an edit's file name opens the file in Code, and the buttons in its corner, such as Open in Code and Revert, say what they do in a tooltip.
• Under a message, "Sent while working" sits on the right and slides aside as its Copy and Rewind buttons fade in on hover.

• On Claude, Full access no longer asks about anything, and Auto stops asking about commands that only read, such as sed -n, grep and head, also after switching from Accept edits or Debug in the middle of a conversation. Accept edits and Debug still ask before removing, moving or overwriting files, and sed only when it edits a file in place.

• In Code, the Git sidebar's Staged and Changes headers stay at the top while their files scroll, and Write a Message drafts the commit message from what would be committed, written the way the repository's commits are.

• The desktop app, redesigned: the threads in the title bar, Agent and Code laid out around the thread, the user's message as a bubble and the newest one moved to the top, compact command blocks, a composer that asks when the agent should ask you and picks the model and its effort side by side, a box over it when the context nears full or a plan's limit is used up, the terminal under the middle with a tab for each, and Settings as a place of its own. In Code, the sidebars switch by icons; Git shows one repository at a time with Staged and Changes, folded generated files, a tree, Commit & Push and Amend; Search leads with the best few files and threads. A thread open in another Jinion can be taken over, which stops its turn there.
• Agents keep to the team's decisions that bind their work: they are told them nearest to the work first, look them up with find_decisions, name the teammate whose decision they kept to, ask before going against one and supersede it once told to, and review_turn names a change that goes against one and warns of a teammate's decision on another branch that touches the same files.
• In a project linked to a team, agents on Claude and Codex record the decisions that matter with record_decision, each shown in the conversation and deletable by its author; Jinion keeps a copy of the project's decisions on the machine, sends what was recorded offline once it can, and deletes the copy when the user loses access.
• Each session sorts the project's decisions by what the HEAD of its folder has: binding once a commit it has carries one, waiting to be pulled, on another branch, or dropped; a draft anchors itself to the commit that carries it, made in Jinion or in the user's own terminal.
• Team decisions show in both apps: each one the agent recorded is a line in its turn that opens to what, why and what was turned down, beside one it kept to and a teammate's on another branch that the turn's files meet. /decisions and the desktop's Decisions page group them as your branch sees them (in your code, not pulled yet, on other branches, yours not committed yet); /link and the same page link a repository to a team or ask to join one, and the status line and title bar say which team the repository belongs to.
• Jinion reads a repository's jinion.config.json and knows whether its user is in the team's workspace, waiting for access, or out; clients link a repository to a project and ask for access through the API.

• Full access, a mode that asks nothing: the agent edits, runs any command, commits, pushes and changes files outside the project without waiting for you, and makes the calls it can itself, saying in its report which ones it made. The first time you pick it, Jinion says what it lets the agent do and asks you to turn it on. shift+tab never lands on it; pick it from the mode menu or with /mode full. On Claude it is Claude Code's bypass permissions mode, on Codex its full access with no sandbox.
• Opening the Preview, or a plan beside a thread, keeps you on the thread you were in, rather than showing the next one in its place.

• A long todo list stays short above the composer, as in the terminal app: the todos already done fold into one line such as 41 done with the last two still listed, then the one being worked on and the next few, and the rest as 5 more.

• The agent's turn shows its work as it happens: each command, edit, search and subagent on its own, marked with how it went, as the terminal app shows it. Click one to see all of it, or press ⌘O to open every one.
• Jinion works with the Preview beside your thread: asked to open a page, it opens it there instead of in another browser, and looks at what it made as you see it. A project of plain HTML and CSS opens in the Preview with no dev server, its pages are listed when the Preview is empty, and a link to one in a message opens there too. Directions to pick from open in the Preview by themselves.
• Code mode edits code: every text file opens in an editor you can type in, saved with ⌘S, with find and replace, multiple cursors and the project's .editorconfig. A tab with unsaved changes shows a dot, and a file changed on disk since you opened it can be reloaded, compared with yours, or kept as yours.
• Code mode understands TypeScript, JavaScript, JSON, CSS and HTML: errors and warnings underlined as you type, hover, go to definition, find references, completion, signature help and rename across files, from language servers that come with the app (TypeScript 7's own, or your project's). The Problems panel lists every error in the project, and Settings → Editor can format a file each time you save it.
• Code mode picks up where you left it: after a restart the files and changes you had open come back in their groups, each file where you were in it, with the edits you hadn't saved, and the Files tree keeps the folders you opened.
• Code mode has a status bar: the branch and what waits to commit, the errors and warnings, and for the file shown its cursor, indentation, encoding, line endings, language and language server, each opening what it is about or a choice to change it. The core says how a file's language server stands through lsp/server, and starts it again with lsp/restart. The workbench's status items can belong to a mode and show only when they have something to show, and a tab can be retargeted to show another in its place.
• Better looks where your project has none yet: before drawing a new look, Jinion looks at how strong products do it and tells you what it took from them, then draws each direction as a real page with care for type, spacing, color and every state, never as a description alone.
• The Changes and Git tabs show each file's diff in the editor, one under the other with what didn't change folded, unified or side by side. Edit the new side and save it with ⌘S; comments on lines work as before and still go to the agent in one message.
• Directions you can see and pick: when Jinion offers you directions for a look, it shows each as a real page in a viewer of its own, at an address on your machine, with the rounds of the project beside it. Pick one there and Jinion gets it as your answer. Nothing is written in your project until you pick.
• Right-click a file or folder in the Files tree to open it beside, ask about it, add it to a message, see or discard its changes, copy its path, reveal it in the Finder, open it in a terminal or search in it, and rename, duplicate, create or delete in place; several picked with ⌘ and ⇧ are acted on together, ↩ renames, ⌘⌫ moves to the Trash and ⌘Z undoes. The core takes a file's changes back with git/discard and opens a terminal in a folder through terminals/open.
• Drag files and folders in the Files tree into another folder, or drop files from the Finder to copy them in: the folder they land in is marked, one held over opens, the tree scrolls at its edges, a name already taken asks to replace, keep both or skip, and ⌘Z moves them back. ⇧ and the arrows extend what is picked. files/move and files/copy take keepBoth, which names one whose name is taken as the Finder's Keep Both does.
• Code mode's editor tells who last changed the line you're on, and when, faint after its end; rest the pointer on it to read the commit, click it to open the commit with every file it changed. Toggle Blame shows the same beside every line.
• Code mode's Search finds text in the project's files too, matching case, whole words or a regular expression, in the files you include or leave out. Each line found opens its file with the match selected, and what was found can be replaced in one file or in all of them.
• Code mode's sidebar has buttons at the end of its header, per view: Files has New File, New Folder, Refresh and Collapse All; Search has Refresh, Clear and Collapse All, its files' lines folding away; Git has Commit, Refresh, Stage All, and More with Pull, Push and Discard All. Right-clicking the header picks which show, kept with the window. The core pulls and pushes a repository through git/pull and git/push.
• Open files follow the disk: when the agent or another program changes one, its tab shows the change at once, keeping your cursor and scroll; a file with edits you haven't saved says it changed, so you can reload it, compare, or keep yours.
• + and ⌘N in Code mode open an untitled file to write in, plain text until a language is picked; ⌘S asks where in the project to save it, ⇧⌘S saves any file as another, and an untitled file with text asks before it closes and comes back after a restart. ⌘N in Agent mode stays a new thread.
• Every button says what it does: an icon button's name shows in the app's tooltip, with its shortcut where it has one, the sidebar and panel toggles are in the title bar, and the menu bar has File, View, Thread and Go menus with the app's commands and their shortcuts.
• The desktop lists only the commands it can run: the terminal's own, such as /exit, /rewind and /feedback, aren't offered there and say so when typed, rather than stopping the project's core; descriptions don't name the terminal's keys; /resume <search> fills the threads' search and /diff <file> goes to that file.
• Failures say so instead of being dropped: a diff that can't be read, a terminal that can't connect, bringing in Claude Code's notes, signing in to an MCP server or an account, and an update that can't be installed.
• The window no longer goes blank when the status bar's language server item meets a file shown on opening or one just closed, and an item of the status bar that fails takes only itself away. Empty folders show in the Files tree, a name already taken keeps its field open saying what has it, and a new untitled file is written in at once.
• The Changes tab, the Git diffs and a commit's tab use the full width: each file's title stays at the top while its diff is in view, and what the page counts and offers floats in a toolbar at the bottom.
• Feedback on Jinion as a whole from the desktop's title bar, in every mode, sent with the shown thread's last turn when you choose to share it.
• The desktop's inner pages are drawn as the window's own white cards: Settings lists only the pages that work, Appearance, Personalization, Editor, Usage and Profile are rows with a switch or a menu at their end, Skills shows Use as you point at one, and MCP servers turn on and off with a switch.
• A message shows the moment it is sent, with the agent at work under it, and a thread that starts fades from the project's status into the conversation. A reply that streams stays followed when something in it folds away.
• The desktop app is light only: the Theme choice is gone from Settings > Appearance and the account menu, and the terminal, diagrams and code are drawn in their light colors. The accent picked still tints the window, the terminal and the editor.
• Line numbers keep their room from the edge in a long file and in a unified diff.
• Links in the agent's messages open where they belong: a dev server on this machine in the Preview, a file of the project in its tab at its lines, the web and mail in the system; nothing moves the app's window away.
• The Project map page opens on a brief in plain words of what the agent follows in the project, with Add the rules under it and the counts below.
• The desktop's MCP page shows each server in one row: its tools, or what went wrong in plain words with the button that fixes it, such as Try again, which connects a failed server again at once.
• Sign out of an MCP server Jinion signed in to, or sign in to it again with another account: o and l in the terminal's /mcp, Sign out and Sign in again on the desktop's MCP page.
• Every menu in the desktop app is one kind of menu: picking a mode, a model, an effort or any other choice closes its menu, the account menu is a menu with the same keys and highlight as the rest, and ⌘K and the project switcher move with the arrows around their ends, Home and End, keeping the highlighted row in view. @jinion/ui adds Menu, MenuItem, MenuGroup and MenuSeparator, and useListKeys for a list picked from a search field; ActionMenu takes a label and descriptions.
• The desktop app moves one way: the sidebar and the panels grow open and shrink closed, a tab enters and folds away as it closes, a new message, the permission and plan panels and queued messages enter, and Send and Stop fade into each other, all on two lengths and a settle curve kept as tokens in the theme, and none of it when the system asks for less motion.
• @jinion/ui has one system for inner pages and settings: Page, Group, Row, Switch, Empty and Failed, in place of List. The desktop's Memory, Skills, MCP servers, Project map and What's new pages are drawn in groups, and MCP servers offers to try again when they can't be listed.
• The sidebar and the panels slide closed as they slide open, without the window flickering: a conversation and the editor beside them draw what they uncover in the same frame, and a terminal fits its new size once the panel has stopped moving.
• The agent checks what a turn wrote against the project map before its report, and writes one short report instead of two; the row reads "Checked against the project · 2 things, 1 fixed" and opens to each point in plain words.
• Settings opens on a General page with the accent, how long answers run and a switch for notifications; Profile puts what it shares under the Jinion account.
• /skill has the agent write a skill from what you describe: it drafts the name, when to use it and its steps, asks whether it is for this project or all of yours, and writes it with a tool of Jinion's own.
• The Changes tab and the Git diffs scroll steadily: what is in view stays put while the diffs around it load, and clicking a file lands on its title.
• A thread opened from Code mode, through ⌘K, search, a card, the Skills or Map page or a new thread, switches to Agent and shows it; ⌘K lists Switch mode and Next permission mode apart.

• Bring your setup from Claude Code: onboarding's last step shows what already works in Jinion (Claude Code's login, skills, plugins, MCP servers), brings your notes in with one key or button, and says what stays behind. If you went through onboarding before, it shows once at your next start. A project with Claude Code notes offers them the first time it opens after that: in the terminal's banner, and on a new thread in the desktop app. The API gains setup/claude, memory/import and setup/claude-done.
• MCP servers in the desktop app: a page that shows each server with its status, where it comes from, its tools and why it failed, where you turn one on or off, sign in to it in the browser, and add a server of your own (a command or an address) or remove it. A call to a server's tool in a thread opens to its arguments and result. The API gains mcp/add and mcp/remove.
• Write and change skills in the desktop app. New skill on the Skills page writes one for this project or for every project; your own skills open in a tab of their own, where you change what makes the agent pick them, their instructions and the other files of their folder, save with ⌘S, or delete them after a question. A plugin's and claude.ai's skills open read-only. Works with Claude and Codex; a change applies from the next turn. The API gains skills/read, skills/read-file, skills/write, skills/write-file and skills/delete.
• See what Jinion read from your project, which the agent works from: what it is built with, how its code is written, how it looks and what its files offer each other. /map in the terminal, with a line of it in the banner; in the desktop app, a Project map page and a card on a new thread. Where the project's linter has no rule for a habit, Add the rules asks the agent to add them.
• See what's new after an update. The desktop app opens What's new on the first start on a new version, with every version since the one you had, and keeps it in the account menu. The terminal says once in the banner that Jinion was updated, and /release-notes shows every version.

• Rate an answer and tell us what went wrong: the thumbs under an answer in the desktop app, /feedback in the CLI, with the conversation sent along only when you choose to.
• Set how long the agent's answers run: Brief, Balanced or Detailed, from the next message and in every project. In the terminal with /answers, in the desktop app under Settings, Personalization.
• The agent explains at the level you show: short and technical when you are, plainer when you describe what you see, and step by step, with what each step does and what you'll see, when you say you don't follow.
• Debug mode, the agent that finds why something fails. It traces the problem through the code, adds diagnostics that write to an evidence log Jinion keeps for the conversation, makes the problem happen or asks you to, and reports the path, the evidence, the cause and what is still open before it fixes anything. /debug <problem> starts it, and shift+tab and /mode reach it too, on Claude and on Codex.
• Pick the model's effort from the composer, beside the model: Default or one of the levels the model has. Changing the model keeps the effort when the new one has that level.
• Jinion now asks you to sign in before you start, with GitHub or with a 6-digit code sent to your email. You stay signed in on your machine, also without a connection. See your account or sign out with /profile in the terminal, or under Settings, Profile in the desktop app.
• Jinion is invite-only during the beta: after signing in, a new account enters its invite code and answers a few questions before Jinion opens, in the terminal and in the desktop app. Fast typing no longer drops keys in the prompt.
• During the beta, Jinion sends how each turn went (how long it took, which model, whether it failed) and the errors it hits, never your prompts, replies or code. Turn it off with /telemetry off, or under Settings, Profile, Telemetry in the desktop app.
• What the Jinion team has to say shows on a new thread in the desktop app, until you dismiss it, and once under the banner in the terminal.
• Files and folders show an icon for their type wherever the desktop app lists them, from the Symbols icon theme: in the Files tree, tabs, quick open, search, Git, diffs, the changes a turn made, the conversation and @ suggestions.
• Each beta user has three invite codes to hand on, each letting one person in: under Settings, Profile in the desktop app, and in /profile in the terminal, with who joined with the ones used.

A message typed while the agent works goes with the composer's button too.

• Once there is something to send, the button shows the send arrow and sends the message into the turn, as Enter does. Before, it stayed the Stop button, so a click stopped the agent instead of sending.
• The button stops the turn only while the composer is empty. Escape stops it either way.
• As before, a message sent into the turn waits over the composer until the agent reads it, and Tab keeps a message for after the turn.

Any file goes with a message, not only pictures, and the agent understands the recordings and videos among them.

• Add a file with the + in the composer, drop it there or paste it. It shows in the text by its name, as a picture does, and a click opens it in the viewer its kind has.
• A file is kept in a folder of the conversation under ~/.jinion/attachments, out of your project. The agent is told where each one is and reads it with its own tools. An Excel workbook also gets its sheets as CSV and a PDF its text, so Codex reads them too.
• A recording is transcribed on your machine with Whisper, in about a hundred languages, each piece with its time; nothing of it leaves the machine. The speech model, 574 MB, is downloaded the first time you attach a recording.
• A video becomes what is said in it and its frames, one each time the picture changes, such as a page opening or text being typed, so the agent can follow a screen recording step by step.
• While a file is read, the composer says what is being done and holds Send, and the file can be taken out meanwhile. A file that can't be read is attached as it is, and the conversation says why.
• The app brings the programs it reads recordings with: ffmpeg under the LGPL, and whisper.cpp.
• A long path in a conversation's line of work is cut within its row rather than pushing the conversation sideways.
• A thread that hasn't started shows what it was told, such as why a file couldn't be read.

The cursor in a long prompt is where the text is.

• Once a prompt was long enough to scroll, the composer drew its lines wider than the ones the cursor moved in, so a click, a selection or typing landed on other words than the ones under it.
• The end of a prompt that ends in a new line was drawn a line off in the same way.

Jinion works on an interface as a design engineer, from a map of your project that it reads from the code and keeps up to date by itself.

• The map holds what the project's files offer each other (components, hooks, functions, classes, types, constants, design tokens and styles), how the project is written (how files are named, interface or type, named or default exports), what it is built with, and how it looks: its tokens, the classes and style values its interface keeps to, the colors written outside both. It reads JavaScript and TypeScript, Vue, Svelte and Astro components, React Native style objects, Swift and SwiftUI, PHP and Blade, stylesheets and templates, and a file is read again only when it changed. A conversation in a worktree reads the map of its own folder.
• The agent looks for a piece that already does the job before it writes a new one, and writes what it adds the way the project is written.
• On an interface it builds from the project's own components, tokens and classes, says what it understood before a new screen, and offers named directions to pick from where the project hasn't decided, such as the first screen of a new project. A pick is saved to its notes and applied from then on.
• It looks at what it made: it takes a picture of a page with Chrome, Chromium, Edge or Brave on your machine, run without a window, or of the iOS simulator's or the Android emulator's screen, at the width and in the color scheme it wants to check.
• What a turn added is compared with the map before the turn is over: a piece the project already had, a file named against the project's habit, a class or a color new to it. The agent puts it right, or tells you what is new and why; what you asked for by name stays as you asked.
• Where your linter, Biome or ESLint, has no rule for one of the project's habits, the agent can offer to add the rule, by its exact name.
• With "describeMap": true in ~/.jinion/settings.json, the small model writes a sentence on what each piece does, so one is found by what it does and not only by its name, and a new piece that does the job of one under another name is caught as the turn ends. It is off by default, since it spends your plan's usage.

Files open in a viewer for their kind, and CSV, Excel and Markdown are edited right there.

• Images show, and a click shows them at their own size. Videos and sounds play. A PDF shows its pages, with the page count and a zoom over them.
• MDX is drawn as its document without running any of it: each component is a block labeled with its tag, its content inside it.
• CSV opens as a table, Excel as a spreadsheet with its sheets under it, and Markdown as the document it draws. Edit a cell by typing or double-clicking it, or write in the document, then save with ⌘S.
• The line over a file says whether it is view only or editable, and whether your edits are saved. Closing a file with unsaved edits asks first.
• A save is refused when the file changed on disk since you opened it, as when the agent edited it, with Reload and Save anyway.
• Saving keeps what you didn't touch: a CSV its separators and quotes, a workbook its formatting and formulas, and a Markdown file every paragraph you didn't change and its frontmatter. A workbook with charts, pivot tables or macros opens view only, since saving would drop them.
• SVG, CSV, Markdown and MDX files have a Source view that shows them as code.

Settings, in a place of its own.

• Settings opens from the account menu and takes the whole window, with its own sidebar; Back to app at its top brings the window back as it was.
• Profile moves into Settings with your name and accounts, and is no longer a tab.
• Appearance has the theme (System, Light or Dark) and the accent color.
• Usage shows what is left of each plan and when it resets, then your history: lifetime tokens, activity, top models and insights. /usage and the activity card on a new thread open it.
• The pages still to come are listed under Personal and Coding, marked SOON.

An account menu under the profile icon, and a theme of your own.

• The profile icon at the top right opens a menu rather than going straight to Profile: Profile, what is left of each backend's plan, Help and the theme.
• Usage left shows each backend's windows as the CLI's status line does, such as 5h 98% left · 7d 99% left; hovering one shows when each window resets.
• Help opens the docs in your browser.
• The theme follows macOS, or stays light or dark, and is kept for the next launch.

A new layout in two modes, and an app that keeps itself up to date.

• Agent and Code, switched from the title bar (⌘E). Agent has the threads, their tabs, and cards on the right for the threads at work, the changes, the preview and the terminals; Code has the files, search and Git.
• Threads sit in a compact list on the left, grouped by month, with a search.
• Projects move into a menu in the title bar, and the search in its middle (⌘K) finds threads, files and commands.
• A new thread opens on where the project stands: what waits on you, what runs, what changed since you were last here, and your activity.
• In Code, selecting lines shows a bar under them to ask about them or to add them to a thread; ⌘L asks about the selection, or about the whole file.
• The composer is a capsule that grows into a box as you write, and the conversation is wider.
• Profile picks the accent color: Navy, Ocean, Plum, Clay or Graphite.
• A folder with thousands of changed files no longer freezes Git or Changes: only the rows in view are drawn, each diff loads as it shows, and the lines changed are counted in the background.
• The app keeps itself up to date: a newer version downloads in the background, and an Update button at the top right restarts the app on it. It works from this version on, so this is the last one to install by hand.

• A message sent while the agent works waits above the prompt until the agent reads it, as soon as its current step is done, and then joins the conversation at that point. Before, it showed in the conversation at once, so it was hard to tell when the agent picked it up. Works with Claude and Codex.

As many previews as you like, and a last thread that closes.

• Preview in the right panel opens a new, empty preview each time, in the group with the others, and counts how many are open. Each keeps its own page.
• The open previews come back with their pages when the app starts again; a closed one is forgotten.
• Threads coming back no longer land among the previews.
• Closing the last thread leaves the window without one, its composer in the middle, rather than bringing a New thread back at once. The next new thread reuses the empty one kept behind it, so empty threads don't pile up.

A preview of your dev server beside the thread, where you point at the page to tell the agent what you mean.

• Preview in the right panel opens the page beside the thread, half the window, with an address bar, back, forward and reload. Its address comes back with the project.
• An empty preview lists the servers running in the project's terminals and the dev scripts of package.json; Run starts one in a terminal and opens its page once it says where.
• Point at the page (⇧⌘C): a click picks an element, a drag picks an area. Esc stops, and shift keeps pointing for more.
• What you pick goes into the composer as a chip, and a note on the page says so; a click on the chip shows it.
• The agent gets each pick with the components it is in when the page is React or Vue in development, its selector, text, styles and HTML, and a screenshot.
• The app's shortcuts keep working while the page has the keys, and links that open a window go to your browser.

Plans of their own, read and changed before you answer.

• A plan opens by itself beside its thread, a third of the window, as a document you can change: headings, marks over a selection, lists and task lists, code and tables.
• Diagrams in a plan are drawn, and edited in a window of their own, the drawing following the text as you type.
• A bar over the plan answers it, Keep planning or Build in a mode, as the panel under the conversation does.
• A plan you changed goes to the agent with a line saying you changed it, so it builds your version.
• The conversation shows a plan as one row that opens it, and draws diagrams too.
• Plans come as a short document: the goal, a diagram where it helps, the steps, the files and the risks.
• Esc in a plan no longer stops the turn, and no "Working" shows while a plan waits for you.

Two fixes to the terminals.

• A command the agent runs in a terminal gives a prompt again once it ends, ctrl+c included, as any terminal does; the terminal still shows how the command ended.
• A long command's name fades out in the terminal list rather than pushing its status past the edge.

Terminals in the bottom panel, shared by every thread of the project.

• Terminal in the right panel opens one at once; + adds another, and ⌘\ splits the one you type in into panes side by side. The list beside them shows every terminal, a split's panes together.
• Terminals belong to the project, so a new thread or another one finds them as they were.
• The agent reads your terminals, and starts what keeps running, such as a dev server, in one of its own: the panel opens on it, with whether it runs or how it ended. It is asked about as any command is.
• Prompts with powerline arrows and icons show as in other terminals, and stay readable on the light theme.
• Tasks shows only when a thread has some.

Comments on a diff, sent to the agent as one message.

• In the Changes and Git tabs, the + beside a line's number comments on it; dragging it across the numbers comments on several.
• A comment stays under its lines, follows them as the file changes, and shows as outdated once they are gone.
• The comments wait in the composer as a pill and go with the next message, each with the lines it is on, or alone from the tab's Send; a click on the pill shows them where they were left.
• A queued message taken back to edit brings its comments back with it.

A composer that does what the terminal's does.

• / lists the commands and the skills, $ the skills and @ the project's files, over the composer or under the line you type when there is no room above.
• Files after @ show as soft blue pills and skills after $ as violet ones.
• Images go in by pasting, dropping or the attach button, at the caret under their file name, so a message can say which image it means; a click opens one large.
• While a turn runs, Tab queues a message, and a queued one can be taken back to edit or removed.
• A command opens what it shows where the window has it: /model and /mode their menus, /context what fills the context, /diff the Git tab, /memory, /usage and /account their pages, /tasks the bottom panel.
• Menus, lists and tooltips are lighter: one line a row, the description faint beside the name.

A profile page in place of Accounts.

• Your name and email, then what you have done with Claude and Codex together: lifetime tokens, the peak day, active days and your streaks, a year of token activity by day, week or in total, your top models and a few insights.
• Every account of every backend in one list, the ones in use marked; a row's menu uses it, signs in again or removes it, and Connect an account adds one.
• The heatmap's squares say their day and tokens in a tooltip that moves along with the pointer.
• Jinion's own icon, in place of Electron's.

A calmer conversation, and tabs that split and move by dragging.

• What the agent does between its words is one quiet list while it works, with a light passing over the step it is on, and folds into one line once done, such as Worked for 27s · 2 files read, 1 command.
• A file the agent read opens in a tab at the lines it read; a file named in its words, such as files.ts:27, opens on a click; an edit opens the thread's changes at that file.
• Text in the conversation can be selected, and the answer and code blocks copied.
• Your message shows its first lines and opens in full on a click, still on top.
• Scrolling up while the agent writes stays where you are; a button takes you back to the end.
• The todos and the agent's questions sit in the composer's own box.
• Drag a tab to a side of the other one to split them side by side or one above the other, or onto another row of tabs to move it; the line between two groups resizes them. Project tabs reorder by dragging along the title bar.
• Scrollbars show only while scrolling or under the pointer.

A git panel to stage and commit, and a thread's changes in a tab of their own.

• Git, under Search, opens a sidebar with a commit box, Stage All and Commit (⌘↵), and the changed files with a checkbox to stage each; beside it a tab shows every changed file's diff, one under another, and a file clicked in the sidebar scrolls there.
• A folder holding several repositories shows each one as its own group, with its branch and commit box.
• Changes, in the right panel, opens a tab with every file the thread changed, for the whole thread or one turn.
• The right panel keeps Changes and Tasks; Files stays in the activity bar.

The projects screen shows each project's sessions, and the title bar opens projects without leaving where you are.

• The projects screen lists your projects on the left and the picked one's sessions on the right, with a search; a session opens in its project's tab, and New session starts one there.
• The + in the title bar opens a menu of recent and other projects, with a search and Open folder, instead of going to the projects screen.
• A button at the left of the title bar goes back to the projects screen.
• Calm empty states when there are no projects, no sessions in a project, or no matches.
• Tabs keep one width: a long title fades out at its end, the close button shows on hover, and always on the shown tab.

The desktop app drawn again from scratch, in a window laid out as a workbench.

• Projects open as tabs along the top, and come back when the app opens again.
• A thin activity bar opens Threads, Search, Changes, Files, Skills, Memory and Accounts; the middle shows tabs: threads first, and a change's diff, a file or a page beside them, split two side by side.
• The conversation keeps your message on top while its answer scrolls; what the agent did is quiet lines that open, an edit opens as a diff with line numbers, and a turn ends on what it changed.
• A new thread is its composer alone in the middle; questions come one at a time in the composer's place.
• The right panel lists the project's changes, files and tasks; the bottom one holds the tasks.
• Light and dark, following macOS, with short transitions.

The first version of Jinion's desktop app, for Apple silicon, unsigned.

• Opening a project is picking a folder; the recent ones come back on the projects screen.
• The same agent as the CLI, on Claude or Codex, picked in the composer's model menu, with the four modes.
• Threads in tabs and in the sidebar; one keeps working in the background, and a notification says when it ends or waits on you.
• Questions, permissions and plans to approve take the composer's place until answered.
• A side panel with the files a thread changed as diffs, the project's files read-only, and the todos and background commands.
• Skills, memory, and accounts to sign in with Claude or ChatGPT.