What's new in Wrappit
Versions follow semver: patch releases fix bugs without changing behaviour, minor releases add features or change defaults, a major release may break existing setups.
Unreleased (1.3 betas; beta 36 on 2026-11-11)
- AI costs (after beta 35): every AI call is pinned to a cheap model,
claude-haiku-5-5, and never inherits the person's default (before, aclaudecall with no--modelran on whatever the Claude Code settings named, often Opus). The model is chosen by--model, thenWRAPPIT_AI_MODEL, thenai-model: <name>in .wrappit/config, thenai-model: <name>in ~/.config/wrappit/config, then the default. Codex gets-monly when a model is chosen; OpenAI keeps its own default; the Claude API default moves from claude-opus-5 to claude-haiku-5-5. Theclaudecall runs in an empty folder with no MCP servers, slash commands, tools or saved session, so each call carries far less context. The Claude Code name shows the model: "Claude Code (claude-haiku-5-5)". - Templated notes (after beta 35): files that don't need an AI to describe them get a plain note Wrappit writes itself: JSON, JSONL, CSV, TSV and Parquet data, lock files (yarn.lock, go.sum, Cargo.lock...),
.designfiles,.out,.errand.logfiles, images, media, fonts and archives, files in fixtures, testdata, runs, artifacts, generated and snapshots folders, binary files, and any file over 40 KB. The note says the file's kind, size, line count, folder, the files it uses and uses it, and the other files with the same ending in its folder, and it says it wasn't written by an AI. Templates go through the same draft, accept and stamp flow. A secret-looking file is still refused, and a file that is binary on disk but text in the commit is refused as before, since its note would describe the wrong bytes. - A cap on AI notes (after beta 35): no more than 25 files go to an AI in one run. Above that,
wrappit fillandwrappit notessay how many files need AI and the token estimate (~input + ~output, and the model), and ask first at a terminal (stopping without--yesin a script, as before for fill). A commit or save never asks: over the cap it writes templated notes for the files and says so in one line.wrappit fill --yesand the newwrappit notes --yesgo past the cap; that is for a person to type, not an agent.wrappit notes --dry-runandwrappit fill --dry-runlist which files would be AI or template, with the model and the estimate, and call nothing. - Kill switch (after beta 35):
WRAPPIT_AI=off(also none, 0 or false), orai: offin .wrappit/config or ~/.config/wrappit/config, turns every AI call off: drafts, fill, notes, verify, the stamp review, the project summary and the belongs check. Nothing is run and no request is sent. Commits and saves then write templated notes and go on; fill, verify and summary print one line and exit 0; a warn-mode stamp says once that the notes are stamped without a review. - Cheaper prompts (after beta 35): a file's prompt carries only the project summary's Purpose and Architecture overview, cut to 2 KB; the diff sent with it is cut to 8 KB (was 40 KB); a refreshed project summary keeps each section under 6 KB. The stamp review and
wrappit verifydon't review data, generated or templated files, and skip files over 20 KB (reported as skipped, not failed). - Desktop lag (after beta 35): the app's unused-files search (desktop app and web app) is stopped after 2 minutes, killing the git search it started, and the tidy panel says so in plain words and points to
wrappit tidy, which still waits for the full list. A stopped search keeps the last good list and isn't tried again for 10 minutes unless the folder changes. The desktop tidy panel no longer keeps showing an old error after a good list comes back. - Shorter note drafts (after beta 35): the draft prompt gives the 250-word limit and, with an old note, keeps its wording where it's still true and changes only what the change touches. The draft list marks a draft over 250 words ("long: N words ... trim it with wrappit notes edit <file>"); it can still be accepted.
wrappit notes <file>(after beta 35): a named file that isn't drafted now says why (note up to date, no note yet, out of date from an earlier save, empty sections, another problem, no note kept, or gone) with the command that fixes it, instead of always "its note is up to date".- Line ages (after beta 35): "started N days ago" counts calendar days, so a day changed by daylight saving time no longer adds a day late in the evening.
- Get it steps (after beta 35): the Get it box's "How to run it" now comes from the project summary when there's no command and no README section, and its code spans show as code.
- Saves for each visitor (after beta 35): a page can keep each visitor's own saves (game progress, settings) in that visitor's browser. It loads
<script src=".wrappit/local.js">(from a subfolder,../.wrappit/local.js), placed early in<head>, before the page's own scripts, and useswindow.wrappit.local:available(),get,set,remove,keys,clearandusage. Each call returns a promise; a failed one rejects with an Error whose.codeisunavailable,invalid_argument,too_large,quota_exceededorrate_limited. A key is 1 to 512 bytes and a value up to 2 MB as JSON. A page holds up to 5 MB and 512 keys in each browser; saves run at about 10 a second, in bursts of 30. The browser's own storage limit for Wrappit pages can also give quota_exceeded. It works for anyone with the link, with no sign-in, on desktop and phone, and each page's saves stay apart. When the HTML file has the script tag, Wrappit shows the page in a small frame that keeps the data; fullscreen, autoplay and game controllers work, and camera, microphone, location, clipboard access, screen wake lock and Web Share are off on pages that use wrappit.local. A plain link to another file of the page or to another site, and a GET form submit, loads as a new address in the browser; script navigation to another site (location.href), form posts to another site, and links with target="_top", don't work on pages that use wrappit.local, so use a plain link or window.open for a new tab. Moving to another file of the page with script works. It isn't available (available()gives false, calls rejectunavailable) where the browser or its mode blocks site storage, for a copy opened outside Wrappit, when the script is added at runtime instead of in the HTML, and in Safari older than 16.4. Browsers may clear it: private windows keep it until the window closes, Safari clears a site's data after 7 days without a visit, a browser short on disk can clear it, and clearing site data for pages.wrappit.dev clears every page's saves. Usewrappit.localfor each visitor's own saves andwrappit.datafor data everyone shares;wrappit.datais unchanged.wrappit page apiexplains both, and the brief and the rules say it in one sentence. - Side work is never forgotten (after beta 34): every git worktree of a project is a line now, including Claude Code's own
.claude/worktreesfolders and folders with no branch, and each line has a state: open, finished, merged or abandoned (shelved stays as it was).wrappit line done <name> "what's done"marks a line finished (waiting to be kept),wrappit line abandon <name> "why"takes it off the reminders without deleting anything, andwrappit line open <name>undoes either. A line stays on the reminders until it's kept, shelved or abandoned:wrappit status, the brief andwrappit linesshow each one with its state and age; the app's project tile shows "N open lines · oldest N days" and a project's page says which lines aren't dealt with on every tab, with mark finished, abandon and open again on each line. The Claude Code stop hook holds a session back while a line it started is still open (lines it made withwrappit try/work, and Claude Code worktrees made during the session that it worked in or named), up to three reminders.wrappit lines --jsonlists every project's lines (also outside a project;--herefor this one), andwrappit lines --allthe lines not dealt with, everywhere. After a backup the line counts go to Wrappit, so the project list and the Wrappit connector's list_projects show them ("3 lines not dealt with: 2 open (oldest started 16 days ago), 1 finished but not merged"). - Notes are settled at commit (after beta 34): the Claude Code stop hook and
wrappit statusno longer nag about notes while files are mid-edit (status lists them under "Changed since their notes", not as work). At commit, every changed or new file whose note is out of date gets a draft written by the configured AI from the file's diff and its old note, shown in one list:wrappit notesmakes the drafts (a blocked commit makes them too),wrappit notes acceptwrites and stamps them all and stages the notes of staged files,wrappit notes edit <file>gives a draft's path,wrappit notes reject <file>drops one.wrappit save --accept-notes "msg"does it all in one run.wrappit stampstill works for notes written by hand.drafts: offin .wrappit/config, or WRAPPIT_NO_DRAFT=1, keeps the old blocked message. In a scripted session of 10 edits and 2 commits, an agent that follows the rules went from 10 stamp calls and 10 note edits to 0, and an agent that only reacts to hooks went from 10 stop-hook blocks and 10 stamps to 2 blocked commits (one per commit) and 0 stamps. - The project summary refreshes itself (after beta 34): once
.wrappit/PROJECT.mdis more than 25 commits behind (summary-every: <n>oroffin .wrappit/config),wrappit notesdrafts a fresh one from the notes and the commits since, in the same list. Wrappit rewrites only the part between thewrappit:automarkers; the first refresh moves the six standard sections inside them and keeps any other section, and the title, outside, word for word.wrappit summarysays how far behind it is;wrappit summary refreshrefreshes it now. - Global rules only change when asked (after beta 34):
wrappit brief --refreshno longer rewrites ~/.claude/CLAUDE.md and the other global rules; it says when they're older andwrappit setup --refreshupdates them.wrappit setuprun without a terminal (a script or an agent) needs--yes. Every change to a global file keeps the old copy as<file>.wrappit-backup. Test runs (WRAPPIT_TEST, set by the test suite, which now also fakes CODEX_HOME) refuse to write anywhere in the real home folder, found from the account, not $HOME.
- Pages and home stay put (after beta 32): redraws no longer jump the screen to the top or flash it. The home list (the app's and wrappit.dev's) changes only the parts that changed: a project's counts fill in on its own tile, the tiles keep the order they were first drawn in until you navigate, and the scroll and focus stay where they were. The still-counting projects are asked again every 1.5 s (up to 30 s; never while the tab is hidden). The pages and workspaces views, the account block on wrappit.dev (mounted once, not asked for again on each redraw), a project's refresh (no "Loading…" and no jump), the Picture tab (its map answer is kept for the same state) and
wrappit view's live poll (it writes a list only when it changed) all keep their place too. A project still being counted has its branch and last commit time from the start.
- Saved page data (after beta 32): a page can keep small data on Wrappit (ticks, answers, scores), since pages still have no cookies or browser storage. The page loads
<script src=".wrappit/data.js">and useswindow.wrappit.data: each saved thing is a small JSON object (up to 16 KB) in a collection, up to 20,000 objects and 10 MB a page. The owner can always change it. People with a page's link only read it, unless the page is shared withwrappit page share <name> link --viewers write(--viewers readtakes that back, andwrappit page publishtakes--viewerstoo).wrappit page listmarks the pages whose link can save. From the terminal,wrappit page data <name>lists the collections and says who can change them,wrappit page data <name> <collection>prints every doc as one JSON line,<collection> <doc>prints one doc,--set '<json object>'(or--set -for standard input) saves a doc and--deleteremoves a doc or clears a collection.wrappit page apiprints how a page uses the data. The rules and the brief say it in one sentence.
- Project groups (after beta 32): a project can be in a group that isn't a project of its own:
wrappit part-of --group <name>, and a group can sit inside a group with a path of up to four names (wrappit part-of --group "GAALE/GAALE Model"); a project is either part of another project or in a group, never both, andnonetakes either off.wrappit projects [--json]prints every project as a tree (groups, parts, spin-offs; a project's line folders stay inside it; folders that are gone show "(missing)"). The app's home screen shows each family as a section you can fold ("Other projects" after them), the side list nests groups and parts in both the window app and the browser app, the "part of…" picker offers groups and "New group…". The group goes to Wrappit with the part-of link (only recorded once Wrappit echoes it back), and the Wrappit connector's list_projects shows the same nesting.
- Brief never writes (after beta 31):
wrappit brief(the session start hook, andbrief --global) no longer rewrites a repo's AGENTS.md or CLAUDE.md or the person's global rules, so an agent starting work leaves no uncommitted changes. When a repo's rules are older than this version, the brief says so in one line: "the agent rules here are out of date: run wrappit brief --refresh".wrappit brief --refreshwrites them (and the global rules); init and agents still write theirs. - Save points skip big files (after beta 31): untracked files over 50 MB are left out without being read (
save-max-file: <MB>in .wrappit/config sets the limit), and media (photos, videos, archives, models) over 1 MB are left out by name; other untracked binary files over 1 MB are left out by their first bytes. Nothing is hashed. A folder of untracked media no longer keeps an automatic save point busy for an hour: the automatic run lowers its priority, gives up after two minutes (leaving a note; the next run tries again), and leaves quietly when another save point holds the lock. What an automatic run leaves out is reported once (the nextwrappit savepointshows it). A file moved to a left-out name keeps its old name in the save point. - Home list fills in (after beta 31):
/api/projects, the desktop app's home screen, answers in about a second. Each project is counted in the background, eight at a time, and kept until its HEAD or index changes or 30 seconds pass (edits to files move neither, so their counts show within 30 seconds). A project still being counted shows "loading…" and the screen asks again by itself. The account's pages and repos are fetched alongside the counts, not one after another, and the list doesn't wait for them past that second. The running-agents scan happens once per list. - Status faster (after beta 31):
wrappit statusreads each file once per run and checks note claims with plain scanners instead of regular expressions. On a 41-file repo whose notes name many functions,status --jsontook about 0.7 s and now takes about 0.45 s (what's left is git hashing the files and git grep for names).
- Picture (after beta 31): a project's page opens on a Picture tab that draws the repo as a picture. The main line runs up the page with the newest save at the top, each save labelled. Every line (a
wrappit workortryline, a plain git branch, a git worktree) branches off where it started: solid for a line, dotted when it has its own folder beside the project, faded when it's parked. A kept line comes back where it was merged (hidden until "Show N merged lines"). Each open line's card says how many saves it is ahead of main and behind it, and whether it merges cleanly or would clash (with the files that clash). Its panel has "Merge into main" (only when it merges cleanly, through the same confirm as the tiles), "Park it", and "Pick it back up" for a parked line. The page's tabs are Picture, Files (the file list, with "How the files connect" for the file map), To do and Research. The desktop app answers from/api/map, which now carries those counts and the merge check (kept until a branch, a worktree or a file changes; the check changes no folder or branch). wrappit.dev still says the picture needs the desktop app. - Opens on your projects (after beta 31): a fresh open of the app page always lands on your projects list. It used to remember whether you last had your pages (or, on wrappit.dev, your workspaces) showing and open that again. Now the switch to pages or workspaces holds for that visit only. A link to a project or file still opens it, and back and forward still work.
- Get it (after beta 31): the top of every project's page has a box with the install or run command and a copy button. The author sets it with
wrappit getit set "<command>"(wrappit getit cleartakes it off; it's kept in the project's .wrappit/config and sent to wrappit.dev with the next backup). Without one, the rules read the project's files (no AI): install.sh (a public project runs it from wrappit.dev), package.json (npm i <name>when it says it's published, elsenpm install && npm start), pyproject.toml or setup.py (pip install .), go.mod with a main package (go install <module>@latest), Cargo.toml, a Dockerfile, a Makefile; else a plain "How to run it" from the README's install or usage section. The newest release's file for this computer's system is one big button, the others are listed under it. - Releases (after beta 31):
wrappit release <version> <file>...puts a version of the project on the person's wrappit.dev account, tied to a git tag of that name (made on the current save when missing). The system is read from the file name (windows, mac or linux; amd64 or arm64).wrappit release listandwrappit release delete <version>manage them. Release files count against the account's storage, a public project's files download from wrappit.dev with no sign-in, and a private one's download from the project's page there with the owner's sign-in. The project's newest release is the one the Get it box offers. - Spin-offs on the tile (after beta 31): a project's spin-offs are squares in its tile's right-hand box, after its working lines, each one opening the spin-off (more than fit, "+N more" lists them). A spin-off's tile and page say "spin-off of <project>" with a link back that opens it. The tile keeps its 290 px height.
- Project map (after beta 31): a project's page has a Map button that shows the project as a picture. Lines draws the main line as a column of saves, newest at the bottom, with each working line, idea and shelved line as a coloured track that branches off where it started and rejoins where it was kept; spin-offs and parts leave the map and open when tapped. Files draws every file as a window sized by its size and linked to the files it works with (from the notes' "What it interacts with" and the imports the checker finds), with folders as soft colour groups: zoom in to read a file's first lines, tap one for its note, and double-tap to open it. The desktop app serves it (
/api/map); on wrappit.dev the map says it needs the desktop app for now. - Desktop app lag fixed (after beta 31): the app's tidy-up search (
git grepover the project's untracked files) started again every half minute with no guard, so on a folder with lots of untracked media (not ignored) searches piled up and read the disk flat out. Now one search runs at a time per project, a request while it runs waits for it, the result is kept until the folder changes (or ten minutes pass), and a slow search backs off. Untracked files are searched only when they're small text (under 2 MB, not binary), so big media is never read. Save and the note checks skip big untracked files the same way. - Lines still open (after beta 31):
wrappit keeplists the other lines still open after a keep, andwrappit saveon the main line (and the commit check there) lists them too, in a few plain lines: what each is for, its note, how many saves it has ahead of the main line, whether it has unsaved work, and when it was last saved. A line untouched for three days or more is told to be kept or shelved. The session brief names the open lines in one line, and nothing is printed when no other line is open. Nothing is blocked. - Line notes (after beta 31):
wrappit line note <name> "testing X"sets a short status on a line (120 characters at most), shown inwrappit linesand the reminders;wrappit line note <name> ""clears it, andwrappit line note <name>shows it. A note stays on this computer. - Part of (after beta 31): a project can be part of a bigger one, such as wrappit-workspaces as part of wrappit.
wrappit part-of <project>says which (wrappit part-of nonetakes it off), and the app shows a part under its project: the tile says "Part of" with a pill that opens the project, the project's page lists its parts, and the sidebar indents them under it. It's only a grouping: nothing is copied or merged, and a project can be a spin-off of one project and part of another. The "part of…" button sets it in the app, and wrappit.dev does the same, where its project page's Related projects panel now lists a project's spin-offs and parts too (it showed none before). - Agent status (after beta 31):
wrappit workspace status [--as name] <link> <text>says what an agent is doing now, such as thinking or building it. The people bar shows it next to the agent's name until the agent says something, or for three minutes, so post it again for longer work. - Join status (after beta 31):
wrappit workspace joinsays "listening" in its first presence post and then leaves the status out, so a status an agent set stays while the join runs. Its reply banner tells the agent to post "thinking" before a reply that takes more than a few seconds; saying something clears it. - Chat cleared (after beta 31): when the owner clears the chat,
wrappit workspace joinprints "* <owner> cleared the chat" once. A line the room writes (such as a clear or a mute) prints as "* text", not as someone's words. - Tile side panels always split in two (after beta 30): a tile whose side panels hold one working line or one page now gets a blank slot under the panel (on phones, where the panels sit in two columns, nothing looks different); tiles with two to four panels, the search view and the "+N more" list are unchanged.
- Room agents that stay (after beta 29):
wrappit workspace agent <link> [--as name] [--model M] [--cmd path] [--voice]keeps an AI agent in a live workspace for good, so it no longer drops out when a join's watcher times out or the agent's turn ends. It stays in the people bar, comes back by itself after a dropped connection or a server restart (waits grow from a second to a minute), and runs until it's stopped. Each new line from someone else goes through the room's talk rule: a line with its name is for it, chatter between people and lines that name someone else are left alone, and the rest go to the model, which answers SKIP when the line isn't for it. Replies come from Claude Code (claude -p, Haiku by default), one call at a time, with one conversation per room and name, and the model may run only the room's say, point, draw and look commands. The people bar shows it thinking while the model works; a call over 90 seconds is stopped and says nothing; lines that come in meanwhile wait, and the next call answers the newest one with all of them in view. The link can come from--link-fileor WRAPPIT_WORKSPACE_LINK, so a service's key stays out ofps;--helphas a systemd unit ([email protected]), and--once-testchecks a setup without saying anything in the room. - Agents see and draw (after beta 28):
wrappit workspace look <link> [--out <folder>]saves the newest picture of the board's drawing (the drawer's page takes one 2 seconds after they draw) and of each shared screen as image files, and prints where they went and the part of the board the drawing shows.wrappit workspace draw <link> <tool> <x,y x,y ...>draws on the board as the agent (pen, marker, line, arrow, rect, ellipse or circle, or text with--text), and people watch it being drawn. - Workspace pointer (after beta 28):
wrappit workspace point <link> <card-id | x y>points at a card or a spot, and the agent's dot moves there for everyone in the room; people pick their colour from their name in the people bar, and agents' dots glide and say their name. - Project tiles keep one height (after beta 27): every project tile on the home screen is 290 px tall, on the phone too. A long summary shows whole lines (up to four) and its full text opens in a card: on hover after a moment, on keyboard focus, or on a tap on a touch screen (a tap elsewhere on the tile still opens the project). The tile's panels share its height, so a tile no longer grows with its summary.
- Bigger limits (after beta 27): a page's file can be up to 5 GB (was 20 MB), and a page up to 20 GB and 10,000 files (was 100 MB and 1,000), all counted in the account's storage. A file over 50 MB goes up in parts:
wrappit page publishprints a progress line per big file, sends a part again when it fails, and drops the upload if a part keeps failing. Pages answer byte ranges, so a video can seek and a download can resume. A new file over 100 MB stops a commit (was 10 MB); backups still leave out files over 50 MB unless they're allowed. Save points hold up to 2 GB per project (was 300 MB), and wrappit.dev shows the text of files up to 10 MB (was 1 MB). - wrappit.dev refreshes less (after beta 26): the page looks once a minute, and only while the tab is showing and was used in the last ten minutes, instead of every 5 seconds. It reads a project again only when the list shows it changed (or every ten minutes), and no longer pings; the desktop app is unchanged.
- Workspace reply rule (after beta 26).
joinprints the reply rule under its "Joined" line (read everything, reply only when your name is said, one or two sentences like talking, build on what others said, and don't start every reply the same way), and the brief's live-workspace line says it in one sentence, so agent files in each Wrappit repo pick it up when the brief next runs.--onceprints the same as before. - Live workspaces, first version (
wrappit workspace). A workspace is a room people and AI agents join with a link, on the workspace server at workspaces.wrappit.dev.new "name"makes one for this computer's account and prints its link, shown once;listshows yours with the people in each;link <code>makes a new link (the old one stops working for new people).join <link> [--as name] [--once]takes part: it prints the room's chat as "name: text", says each line typed in, and keeps its name in the room;--onceprints the room as it is and leaves.say <link> "text"says one line. The key stays out of the address: it sits after the # in the link and goes in a header. On wrappit.dev, "Your workspaces" lists them, with a new link, rename and delete. - Workspaces (beta 26). Your own workspace opens from "Your workspaces" on wrappit.dev without pasting its link: the workspace server keeps the owner's link locked (encrypted) and gives it back only to them. "copy link" copies the current link; "new link" still makes a new one.
wrappit workspace link <code>prints the current link, and--newmakes a new one (the old link stops letting new people in). A workspace made before this asks its owner for a new link once. In the workspace: the mouse wheel zooms, dragging a box picks cards and drawings to delete, the middle mouse button moves the board, and "add agent" gives a command to hand to your agent.joinprints each new line of the room as it comes: chat as "name: text" (a spoken line as "name (voice): text"), a card added to the board as "[board add] name: kind link or words", and people joining or leaving as "* name joined" or "* name left". It starts from the room's state's last_id, and it no longer stalls on a page of events that carries pictures or drawings: answers up to 64 MB are read, and an answer it can't read ends the join with a plain message.join --voicemarks the agent as voice-enabled in its presence posts. With no--as,joinandsayshow as "<your handle>'s agent" (or "Agent" with no account);--asstill sets the name. Flags can sit before or after the link and the text. - Card names and the synced mark (after beta 23). A home card is titled with the project's online name, the name wrappit.dev shows, so two folders both called gaale, online as gaale-swarm and gaale, no longer look the same. The folder's path stays on the card, and a project with no online name yet keeps its folder's name. The synced mark no longer depends on the online choice: a project with a repo of its online name on the connected account is synced or behind (Wrappit backs every project up privately), and "not online" means there's no such repo. "Online as" shows only when the card has the folder's name instead. A spin-off's main project is picked by the name the app shows, and spin-off links carry those names too. An open project's page, its top bar and the "Your projects" tree show the same title; the folder stays the project's identity and its path. The live viewer (
wrappit view) andwrappit exporttake the same title from the project's state. - The belongs check (beta 23): when a commit adds new files, an AI looks at the project's purpose and the first lines of each new file. If they look like another project's work on this computer, the commit is blocked and says where they should go: move them there, or if they do belong here, run
wrappit belongs yesand commit again (it covers exactly the staged new files).wrappit belongs off(oron) turns the check off for a project. A project with AI review off (verify: off, or no settings file, as in projects set up before 1.3) never sends code to an AI for it. Only the first 30 new files are looked at; a timeout, an error or no AI lets the commit through. - The line lock (beta 23): git only makes the main line and Wrappit's own lines (work/, try/, dropped/, wrappit-kept/) in a project.
git branch,git checkout -b,git switch -candgit worktree add -bare refused, with the way to start a line instead (wrappit workorwrappit try). A checkout that puts the main folder on a line is undone, and the main folder stays on the main line; if it has unsaved changes it's left where it is, with a warning thatwrappit statusand the brief repeat. Side folders are not affected. Tags, fetches, deletes and save points are unaffected. Projects set up before this get the two git hooks on their next wrappit command;wrappit lock off(andwrappit lock on) turns the check off for a project. - A project's settings belong to the project (beta 23). A line's folder, the folder beside the project, now uses the main folder's
.wrappit/configfor every project setting, so its backups and pushes always go to the project's place online, whatever its own copy says.wrappit statusand the brief say once when that copy differs (its own settings are ignored);wrappit fix-settingsmakes it match, and try, work and mark do the same quietly. - Old names come down online (beta 23). Keeping, shelving, marking or resuming a line, or renaming or deleting one in the app, left its old name on Wrappit when the project wasn't kept there (the private backup still went there). The next backup now takes the old name down, but only while it still holds that line's commit: a name somebody else put there is left alone, and a line made again under the old name is kept.
- Line folders for a person who can't write beside the project (beta 23). When the project's own folder can't be written to, a new line's folder goes in the projects folder (
wrappit setup --projectssets it), and the output says where. Keep and shelve still finish when git can't remove a folder there: the folder is emptied and left (its note says so), and the line goes. - A clear procedure (beta 22): every project has one main line, plus working lines, ideas and shelved lines, each working line or idea in a folder of its own. Project tiles show them in the right third (what each is for, when, how far ahead); lines Wrappit didn't make show as "loose" for you to sort; shelved ones sit behind an "N shelved" link. The tick-box bar stays pinned while you scroll. Pages: a "N pages" link on each tile, and a pages view (switch beside the title) with every page, which project it's from and who can see it. On wrappit.dev, a project only ever starts on a computer: "make it its own project" is done in the app.
- Lines of work are cleaner.
wrappit try "what"starts an idea andwrappit work "what"a working line; each gets a folder of its own beside the project, and the main folder never leaves the main line.wrappit keepmerges a line into the main line and removes its folder and branch (a clash stops it and names the files).wrappit shelveparks a line after saving its unsaved work (dropstill works), andwrappit resume <name>picks it up again as the kind it was.wrappit markmakes a loose branch or a Claude Code worktree a working line or an idea, with a folder beside the project; a program working in that folder stops the move.wrappit lineslists them all, anddirectionsstill works. - Changes made on wrappit.dev (lines renamed, deleted or shelved) reach the computer before the next backup when that's safe. A change that isn't waits,
wrappit linessays so, and that line isn't sent until it's dealt with. Each line's words go up after a backup. wrappit tag old|nonemarks a project old on wrappit.dev: it sorts last, with a grey tag.
- Wrappit is free. There's no trial and no license: every command works, and the commit check always runs.
wrappit activateandwrappit licensejust say so. - The desktop app (
wrappit app): every project in one window, every file and its note, buttons to start Claude Code, Codex or a terminal, and "Checked by AI" marks. - Tick and act (beta 21): tick one project for rename, move to a team, spin-off of..., fold back (in the app) or delete; tick one branch for rename, merge into main, make it its own project, or delete. A project's pages show in the top bar next to its name.
- Branches on the tiles (beta 20): a project with other branches splits its tile, and the right third lists them (a branch with its own folder says how far ahead it is). Click one to see the project on that branch, read-only, or to open its folder. Spin-offs and pages are back to their own places.
- Synced, and faster (beta 19): each project tile in the app says whether it matches the project of the same name on wrappit.dev ("synced", "not backed up yet", "online as <name>" or "not online"). Backups now merge a project's online copy into one pack once it has more than 20, so big projects open quickly on wrappit.dev, and Your projects there shows every tile at once.
- Pages belong to their project (beta 18):
wrappit page publishlinks the page to the project it's run in (--project <name>to pick another,--project nonefor no project). On Your projects, a project with spin-offs or pages splits its tile: the right third lists them, one under another, with a "+N more" list when there are many. Spin-offs show inside their main project's tile instead of on their own. - Claude cloud sessions push to Wrappit (beta 17): on wrappit.dev, Your projects > Your computers > "Set up Claude cloud sessions" makes a token and shows what to paste into claude.ai/code (allowed domains, setup script, token). In the session,
wrappit pushthen sends the work to your Wrappit project of the same name, even from a GitHub copy without Wrappit set up. - Wrappit with Claude (beta 16):
wrappit github connectkeeps a GitHub copy of a project and adds a small GitHub Action that sends every push back to Wrappit, so Claude Code cloud sessions (which open GitHub repos) can work on it;wrappit github statusanddisconnect. For the Action,wrappit push --to owner/nameand a WRAPPIT_TOKEN that needs no settings file. There is also a Claude Code plugin (claude plugin marketplace add hanos1987/wrappit-plugin, then/plugin install wrappit@wrappit) that installs Wrappit and teaches Claude how to use it. - Work together (beta 15): invite someone by their Wrappit name to a project (
wrappit invite <name> --can look|edit,wrappit uninvite,wrappit people), or make a team that owns projects together (wrappit team create|add|remove|list|show|delete,wrappit host team <team>). The other person runswrappit clone <owner/project>, andwrappit pushsends their work back. Your unsaved work stays private to you. On wrappit.dev, shared and team projects carry a tag, with a People box and a Teams section. - Rename a project online (beta 15):
wrappit host rename <new-name>. Big projects rename in rounds; the old name keeps working until it's done. - Your projects is the one page on wrappit.dev (beta 15): the old dashboard is gone, and your storage, pages, computers and install command sit under the grid. Point at a project for a tick box; tick some and delete them from the bar on top, or right-click a project. The app on your computer has the same right-click menu and tick boxes (there they take a project off the list).
- Web pages (beta 14):
wrappit page publish <file or folder>puts a page an agent built on your Wrappit account. It starts private;wrappit page share <name> linkmakes a link anyone can open with no sign-in and no notice, andpublicgives a public address. Publish again to update it and keep the link.wrappit page open <name>gives a one-hour link for a private page, andlist,deleteandshare ... privatedo what they say. Pages run in a sandbox (no cookies or storage) and count toward your storage. Also on the dashboard under "Your pages". - Buttons and links look the same everywhere (beta 14): the typewriter style in the app page, the window app, wrappit.dev and the sign-in box. Words in a monospace font with no boxes; the main button has a thick line under it.
- Agents know about web pages (beta 14): the rules and the brief say how to publish and share one.
- Spin-offs (beta 13):
wrappit create <name> --from <project>makes a side project that stems from a main one, as its own project with its own history and its own place online (--emptystarts it with nothing). Both apps show it under its main project.wrappit fold-back, run in the spin-off, brings its work back: a copy's saves are merged in, an empty start comes back as a folder named after it, notes and all. - Backups reach every project (beta 13): the app backs up projects another user owns (it keeps its own bookkeeping in your settings instead of the project), and
wrappit backup --allruns once a day by itself, so projects you haven't saved in a while still get backed up. - The app's file list is one tree from the top (beta 13): "Your projects" goes back to the home screen, every project is listed, the open one unfolds to its files, and folders and the open project fold away, also while searching or filtering. Every saved file shows, including ones in dot-folders, with a ring for files that don't need a note.
- To do and Research pages (beta 13): each project has them in the tree and as tiles on its overview, in the app and the window app, so ideas for later and what research or tests found are easy to find.
- Agents' rules bring themselves up to date (beta 13):
wrappit briefrefreshes older copies of Wrappit's rules, so agents know the newest features (to-do, research, staying on the main line) without looking. - One project in several folders (git worktrees, often one per AI session) shows as one card in the app, with the other folders listed and how far each is from the main folder ("8 new", "finished"); the project page lists them with Open buttons.
wrappit try <name> --foldergives an idea its own folder for a second session;keepordropthere finishes it and removes the folder. Agents are told to stay on the main line otherwise. - Window app fixes: the window no longer blows up on a screen that reports a wrong size (it uses the desktop's own scale); Claude Code and Codex start in projects root owns (they weren't found after the sudo password); backups and save points no longer pile up in projects another user owns (179 stuck backups once used 14 GB).
- A new look for the app, the window app and wrappit.dev: white sheets on a grey desk, black for what's selected, and a shape for each note's state (grey dot fine, yellow triangle out of date, red square missing). Note sections sit side by side as tiles. Fonts are Hanken Grotesk and DM Mono, bundled, so it looks the same offline. The window app now wraps note text itself, which fixes words breaking one letter per line.
- The app is a real program window now (beta 9), not a browser page: on Linux it's a second program,
wrappit-desktop, whichwrappit appdownloads once if it's missing; on Windows it's built into wrappit.exe. Without a screen or the graphics libraries it falls back to the browser. - The window app looks like the app page and the promo video (beta 11): project cards, the file list with filters and coloured dots, number tiles, notes as cards, search, and a light/dark switch. File names in notes open that file. On wrappit.dev, each project opens in the same page.
- Notes are checked for correctness: names and paths a note mentions must exist, and with
verify: warnorrequirean AI reviews each note. wrappit tidylists files nothing seems to use.wrappit retiretakes old files out with the reason and note kept;wrappit restorebrings them back. The app has a tidy-up area with Retire and Restore buttons.- Ideas on the side:
wrappit try <name>starts one (unsaved work comes along),wrappit keepadds it to the main line,wrappit dropshelves it with its half-done work;wrappit directionslists them. - Propositions: ideas for later. When something new comes up mid-task, the agent parks it with
wrappit propose "idea"and carries on; the brief lists them for the next session andwrappit proposition P<n> start|donemoves them along. Only the person declines one. They live in.wrappit/PROPOSITIONS.md, kept sorted. - Research tracking:
wrappit research add <topic> "finding" --source --tagkeeps what a look-up found in.wrappit/research/<topic>.md, grouped by tag, repeats merged, corrections kept struck through, with open questions and a "Where it stands" summary. In Claude Code, a turn that searched or fetched the web and logged nothing is asked to log it before stopping. - Agents get a guide to every feature at the start of each session, and are told to ask once where each project is kept online (
wrappit host) and never guess;wrappit pushsends it there. - Save points (beta 6): once a computer is connected, unsaved work is recorded every few minutes and backed up (never secrets, ignored files, downloaded or built folders, or big new files). After a crash or on another computer,
wrappit recoverbrings it back as unsaved changes, and never over work that's there. - Beta 8: a copied project folder gets its own save points; one big file holds back only its own branch; save points upload only what changed; branches with any name git allows are backed up; passwords in settings files are kept out; merges of already-committed big files aren't blocked; Go and Electron build/ folders count as code; recover warns when your account has newer saves of the branch.
- Save points, hardened (beta 7): each copy of a project has its own save points, so clones, restored backups and other computers never touch each other's; a reset or a commit never deletes the save point that held the work;
wrappit recoverdecides file by file and never writes over work (bring back chosen files withwrappit recover <id> <file>...); save points travel and are stored apart from branches, don't count against storage, and git push --mirror can't publish them. Junk rules only treat build folders as output when their tool is present, find virtualenvs anywhere, and let the project's own .gitignore win. More secrets caught. - Junk stays out (beta 6):
wrappit initadds a .gitignore block for node_modules, build output, caches and private files; the commit check stops new files in those folders and big new files (allow one for good withallow-big:in .wrappit/config); backups never send files over 50 MB. - Automatic, signed updates: Wrappit checks wrappit.dev once a day and updates itself only when the release is signed by Wrappit and checks out (
wrappit update,--offto stop). - Wrappit's own hosting is open (beta 5): make a free account on wrappit.dev, connect a computer (
wrappit login, or the install command on your dashboard), and every project is backed up privately by itself;wrappit host wrappitkeeps a project on your account,wrappit pushsends it, and plaingit cloneworks from git.wrappit.dev.
1.2.0 (2026-09-26)
Fixes from a hostile review of 1.1.1. Upgrading is strongly recommended.
Security
- Symbolic links inside a repository are never followed. A cloned repo could make
fill,neworstampoverwrite files outside it (such as ~/.claude/CLAUDE.md), or leak an SSH key into an agent's session. fillnever sends secret-looking files (.env, keys, credentials, tokens) to an AI, even when named, and tells the model file content is data.wrappit viewonly answers on 127.0.0.1 and needs the access code in the link it prints, so a web page can't read your notes.
Your data
saveno longer runsgit add -Aor pushes by default. It commits files git already tracks (and renamed files); new files only with--add; secret-looking files are refused. Push with--push.saverefuses during a merge, rebase, cherry-pick or revert, so conflict markers can't be committed.
The commit check
- Judges only what's being committed (the index), never the disk.
- A change to .wrappit/ignore that would exempt tracked files is blocked unless you set WRAPPIT_ALLOW_IGNORE=1.
- Deleting or gutting a note whose file stays, or removing .wrappit, is blocked.
wrappit deinitis the proper way to stop using Wrappit. - Notes must carry a stamp and name the files the committed code imports.
- Merge commits are checked (pre-merge-commit hook).
- If wrappit isn't installed, the hook warns instead of blocking commits.
Other
- Agent rules say to commit with plain git, naming files.
- File names with a newline or leading quote no longer break commands.
- Empty files never inherit another file's note.
- The Claude stop hook counts reminders per session.
- A trial start date in the future counts as ended.
- New repos' default ignore list covers common secret files.
1.1.1 (2026-09-23)
- Home-folder repositories are not projects; agents ask before
wrappit init.
1.1.0 (2026-09-23)
wrappit setupandwrappit create.
1.0.0 (2026-09-23)
- First release.