ZIP, tar and cpio readers can stop their member listings early, but firmware extraction ignored their truncation flags, so directory entries could use up the member limit and later files were left out while the result reported complete coverage. A cut-short member listing, in any region or nested archive, now marks the extraction truncated with a limitation saying what to raise or inspect.
A ZIP stored inside a firmware ZIP member could supply the first plausible end record, so the scanner cut the outer archive short at the inner one: extraction left out outer members and wrote the inner contents at the wrong path. Each end record and central directory is now matched to the archive whose extent it describes, so a nested ZIP stays a member of the outer one and its siblings are all extracted.
Firmware extraction decoded ZIP members into a queue before charging their output bytes, so each member got the same remaining budget and a small compressed archive could hold many times the output limit; a member that hit the decode limit also left the truncation flag unset. Paths and the remaining file and byte limits are now checked before a member is decoded, each member is decoded only up to what's left, and a member stopped by the limit marks the extraction truncated.
Filesystem recovery already owns each extracted file's bytes, but firmware extraction copied them into its output queue and kept the originals, so a large recovered file took two full copies in memory before it was written. The recovered buffers are now moved into the queue. Path checks, byte and file limits, nested scans and the report are unchanged.
A truncated asset catalog tree or node header could give no entries and no warning, and apple_assets_list then reported a complete empty listing; other interrupted tree walks kept what they read but called the result complete. Tree completeness is now tracked through the headers, child and leaf links, missing blocks and walk limits. Readable entries are kept, and an incomplete tree marks coverage partial, sets tree_incomplete and says so in the summary. Legal empty trees still read as complete.
apple_archive_decode built every object row before paging and copied a shared class name once per object while counting classes, so a 97 KB archive with 1,024 objects sharing one 64 KiB class name held 64 MiB of class text even when one row was asked for. Only the requested rows are built now, and class names are borrowed from their shared class object while the class counts are taken. Totals, order, offsets, limits and the output shape are unchanged.
app_builds_line_up paired only 1,448 of about 36,000 functions across two Rust toolchains, because every v0 crate hash changed, so exact names rarely matched. A new name_without_hash stage, after exact names, pairs Rust names (legacy and v0) that are equal once demangled without the compiler's hashes, and keeps the instantiating crate so each crate's copy of a generic impl stays separate. Called names are compared the same way, so the structure fingerprint survives a toolchain change, and a pair whose names differ only by hash isn't counted as renamed. On the same two cargo builds this pairs 14,036 functions (13,356 by name), with masked-bytes pairs down from 888 to 233. The crate lookup reads only the end of a name, so a long crafted symbol can't make it slow.
The UnityFS directory reader checked that compressed blocks fit the file but returned member offsets and sizes without checking the uncompressed stream they point into, so a member could lie past all data, overflow, or claim bytes in an empty stream. Block sizes are now summed with checked arithmetic, and a member whose range doesn't fit the stream is marked as unreadable. It keeps its directory entry, but its contents aren't read. Listings say how many such members there are, mark coverage partial and count objects as "at least", and the other members stay readable. An overflowing total of block sizes still makes the table unreadable.
A small metadata or object read from a Unity bundle read and copied every block it touched in full, stored blocks included, so a valid stored block over the 512 MiB read limit made ordinary bundle and object listing fail even for a 496-byte member, and smaller stored blocks allocated bytes nobody asked for. For a stored block the reader now checks that its stored and uncompressed sizes agree and reads just the requested part from the file. Compressed blocks keep the existing decompress-and-cache path, and the 256 MiB per-request limit stays.
ASAR entry and depth limits didn't bound the combined size of expanded paths: a compact directory tree could repeat one long parent prefix across thousands of short names, and a valid 1.5 MB archive kept 145 MB of path text. Expanded entry paths and rejected names now share an 8 MiB budget, checked before each path is built; when it runs out, the entries read so far are kept and the listing is marked truncated. core_archive_extract used to ignore a truncated listing and call the extraction complete; for ASAR and ZIP it now extracts what was listed, adds a limitation that the listing was cut short, and marks coverage partial with no claimed total. The JavaScript app analysis carries the same flag.
After the WebAssembly reader began leaving out derived metadata once its byte budget is spent, formats_wasm_module_show still said lists stop at 100,000 entries even when the byte budget ran out much earlier, and its summary view left out the reader's truncated flag. The limitation now says lists or derived metadata are incomplete and points to the warnings for which limit was reached, and the summary view includes truncated as the complete view already did.
DEX disassembly copied array and switch payloads into every instruction that referred to them, and the instruction cap didn't bound those copies: a 77 KB input with 2,048 references to one 64 KiB array ran out of memory under a 128 MiB limit. A shared payload budget (64 MiB by default, decode_with_payload_limit to choose one) now pays for each payload and each attached copy before it is made. A payload that doesn't fit is left off its instruction, whose offset, name and width stay, and the listing is marked incomplete. The payload lookup no longer clones payloads, and android_method_show says a listing can be partial because of instruction or payload limits.
closest() in the browser script checker matches on the lowercased name, so its "testId" pattern could never match. It's removed; testId still maps to test_id through the lowercase "testid" arm, and a new test checks testid, testId, TestID, data-testid and data_testid.
The binary XML reader marks a recovered or capped manifest as truncated, but android_package_show dropped that flag and called its evidence complete, counted by the APK's ZIP entries, even when the manifest was missing or unreadable. android_components_list also reported complete coverage on the last page of a recovered manifest. Package evidence is now complete only when the manifest read in full, and component pages of a truncated manifest stay partial, with no claimed total and next_offset kept for paging.
A project's capture/ can be left by a study in the other mode, and the run only checked that the folder existed, so a Clean room build could be handed a Deep capture, and a Deep run could skip its inside study by using a Clean room one. craft.json now records the mode the current capture was studied in (capture_deep, format version 5; a version-4 capture migrates as Deep, like a saved session), and a run studies again when its capture isn't from its mode. A study clears the record before it starts, so one that fails partway leaves nothing a later run trusts, and a Clean room study removes the files only a Deep study writes (how-it-works.md, page.html, runs/). The extractor's fresh-study decision and the run queue use the same check.
The JVM tableswitch and lookupswitch decoders reserved room for their declared entries before checking those entries were there, so a truncated 12-byte table could ask for 16 MiB; and a lookup table took duplicate or descending keys, though its signed keys must strictly increase. The whole table must now be present before anything is reserved, a dense table's count is converted without narrowing, and a lookup table with keys out of order isn't decoded (the instructions before it are kept and the coverage is reported incomplete).
In a live run, an agent asked core_evidence_browse for a list by a name that wasn't one and had to run the tool again to find the right one, as neither the result's summary nor the error named its lists. A result's summary now carries its lists and their lengths, by the names core_evidence_browse reaches them with, in a detail: summary answer, the MCP server's summary-first answer and browse's own summary; and browse's errors for a name that isn't a list say which lists there are.
A text file (notes, source code, settings) was a target of unknown kind, so the target list and triage called it a file we don't recognise yet. Text now has its own target kind, found by the same check the text reader uses (a byte-order mark, or valid UTF-8 with no zero bytes and few control characters near the start) after every other format, so lists and triage call it a text file and point to core_text_read. A binary file stays unknown.
POSIX makes everything after = in a ps -o argument the header, so FreeBSD's ps read pid=,ppid= as a single pid column headed ",ppid=". The process tree then had no parents, a runner's child window was never found there, and snapshot_finds_an_owned_child_on_this_host failed on every FreeBSD run since it was added.
A text file outside a build (a script, Markdown, settings, a log) could only be searched byte by byte: the native tools refused it and build_file_read works only in a build. The new core_text_read (Deep mode) reads one as text, a page of lines at a time: UTF-8, or UTF-16 with a byte-order mark, invalid bytes shown as U+FFFD and counted, very long lines cut and named, and a file with zero bytes near its start refused as binary. Nothing is run.
Fixes#539
native_publisher_show reported a signed program as changed after signing when its sections had a gap between them, because the file was hashed as one run of bytes up to the certificate table. The Authenticode hash now follows the PE/COFF specification: the headers (less the checksum and the security directory entry), then each section in the order its data sits in the file, then the data after them less the certificate table, so a gap between sections isn't hashed.
On Unix a folder's name may hold a backslash, and turning it into / named another package (cmd/foo\bar became ./cmd/foo/bar); Go reads a backslash as a separator, so keeping it wouldn't help either. The package is now written from the path's folders joined with /, the same on every system, and a command folder whose name holds a backslash gets no inferred launch.
A Go project's command package was written with the system's separator, so on Windows the launch test expected ./cmd\viewer while the launch gave ./cmd/viewer (right for go run only by accident, from a mixed path). {package} now always writes the folder with /, as Go names packages, and the test expects ./cmd/viewer.
A coding agent's saved session counted as the project's history whatever mode it ran in, so after switching between Clean room and Deep a run could skip its study and build from the other mode's capture. A saved session or transcript now counts only in its own mode (one saved before the mode was kept counts as Deep); one from the other mode makes the run study again and replace the capture before the builder is briefed, including an API follow-up whose transcript was rejected for its mode.
In Deep mode, a builder that hadn't decompiled anything was reminded to, but whether it had was kept only for one run, and each request from the person starts a new run. So a builder that had read the original's functions earlier was told "You haven't decompiled anything yet" after every request. It's now kept in the project's craft.json, so a decompile in any run counts.
A question answered from a fork of the builder's Claude Code session reported the whole session's running total, so its cost was hidden. It's now what the total added since the builder's last turn, read before the question starts, and unknown when there's no kept total, never the session's total. The question's cost is added to the project's usage, and a build turn and a question saving their costs at the same time no longer overwrite each other.
A private browser or driven Electron app was stopped only when its process handle was dropped, which a crash, a kill, a force quit or an MCP server stopped by its client never does, so the browser was left running and its profile stayed in the temp folder. On Unix a small watcher now stops the browser's process group and deletes its `craft-*` profile once the app is gone, and ends by itself as soon as the browser does. Windows children are held by a Job Object; whether one outlives an abrupt exit is left as a roadmap line.
Refs #810
A Bun program's modules can carry a stored source map and bytecode, which were only counted in a note. They're now listed and extracted as their own members, in a folder whose name doesn't clash with the program's own files.
A check round in which every check worked is kept, and the next check reuses its results while nothing it looked at has changed: the app's files, the reference and capture files, the kind, stack and mode, the plugin checks and the project's folder. So a prompt that changes nothing in app/ no longer builds and starts the app again, and the check after the builder's turn doesn't repeat its own check. The feed says when results stand. A round with any failure is never kept, so Try again always looks again; the kept round is saved in the build progress.
Play, screenshots and self-tests start a Python project's one package with a __main__.py as python3 -m <name>, and a Maven or Gradle project's one runnable jar (its manifest names a Main-Class, read without loading the jar) with java -jar. Maven now builds with package, so the jar exists after our own build.
craft.json keeps the mode a builder's saved session ran in (version 4, with a migration that counts an older saved session as Deep). A build or question resumes a session only in the mode it was saved in, so Clean room never continues one that may have read inside the original, and a Deep session is kept for a later Deep run.
Source-map data URLs ignore their fragment, ZIP directories are told by their attributes, rejected ASAR names count toward the limit, a HAR with a UTF-8 BOM parses, .NET bundle members stay before the manifest, Play starts a Python project's one installed console script, and Godot and Electron get an absolute project path.
Supersedes #1140, #1141, #1142, #1143, #1144, #1145 and #1146.
Co-authored-by: Afloat <ShuffleMonkey@163.com>
A tree and screenshot that would pass the helper's 16 MiB output cap now fit: the tree is cut to a prefix and reported as truncated, keeping the image, and an image that cannot fit alone becomes a screenshot limitation.
`runtime_ui_read` with `screenshot: true` returns one on-screen window of the pid as a PNG on macOS 14+, restricted by `window_id` when given. Missing permission, a missing window or a failed capture is a limitation with partial coverage, and no permission dialog opens.
Fixes#248
Ubuntu's /usr/bin/chromium-browser is a script that hands over to the snap; the snap is now started directly, with a profile it can use, so a website build gets past Study.
Closes#1054.
* A command of several kinds needs each allowed, and an inbox path split by quotes is still the inbox
* A Windows inbox path split by quotes is still the inbox
* A relative path into the inbox, from the project folder or app/, is a system change
* An inbox path written as a PowerShell parameter or with Bash escapes is still the inbox
The check for the project's records reads a command with quotes and escapes taken out, as the shell joins them, and any mention of `CRAFT_ANYTHING_AGENT` counts as a system change. docs/claude-code.md says these raise the bar and aren't a wall.
A project can allow, ask about or refuse each kind of builder action (web, commands, outside files, publishing, deletes outside the project, system changes, other tools); a kind it hasn't chosen follows Auto mode as before. `project_approvals_set` sets them, and an agent can only make a kind stricter, including through our CLI from its own shell. "Always" on a push, delete or system card allows that whole kind, and pushes are read word by word in every shell form.
Without Screen Recording the capture is refused before the program starts, with where to allow it. The name fallback matches whole words and never the system's own windows, and a window that's late gets up to 10 more seconds.
Closing the app stops analyses and waits for them to end. A Deep build no longer waits on Ghidra for an Electron program, whose logic is in `app.asar`.
Closes#946.
Closes#947.
New Python, Go and .NET projects build and launch through one catalogue shared by the build check, the screenshot and Play; a window is found through the program's descendants, then by name.
`build_files_list` defaults to the project folder for a project edited in place and hides our records from that listing; a listing of one of our folders shows what is in it.
`build_command_run` says where it ran and warns on `app/app/`. Runs load the saved asset keys. `runtime_ui_read` honours `accessibility: false`. Closes#923. Closes #307.\n\nCo-authored-by: SoldierPePe <ahmed.m.alnajjar1@gmail.com>\nCo-authored-by: justinjohn0306 <justinjohn0306@gmail.com>\nCo-authored-by: Tomáš Doubek <doubektomas16@gmail.com>
Pasted pictures get a counter in their name; atomic-write temp files are created exclusively and private from the start; stand-in replay samples keep differing response details.