Files
craft-anything/docs/STATUS.md
T
Tanish Manku 5870bcebed Keep a check that worked while nothing it looks at changes, so an unchanged build isn't built and started again (R2.9) (#1296)
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.
2026-11-09 17:47:23 +08:00

116 KiB
Raw Blame History

Status

What works today and how it was checked. The plan, owners and order of work are in ROADMAP.md. Last updated 2026-11-05. The baseline audit on 2026-10-23 from main had 923 tests passing; workspace clippy, layers, fmt and the secret scan of all history were clean. Chinese UI checks are listed separately below.

What works, and how it was checked

Area State Verified by
Binary property-list object types Accepts compatible version-zero minor signatures and rejects unsupported major versions, invalid simple/date markers and unrepresentable non-string dictionary keys. Typed binary fixtures with valid null, string-key and date controls.
ASAR listings Rejected unsafe names count toward the listing limit alongside retained entries. Synthetic regression invalid_names_consume_the_listing_budget in the formats crate.
HAR input Captures with a leading UTF-8 byte order mark parse like the same capture without it. Synthetic regression reads_a_har_with_a_utf8_bom in the formats crate.
Tar numeric fields Reject negative GNU base-256 encodings when reading unsigned header values. The octal_fields regression covers both a negative eight-byte value and a positive binary value.
.NET single-file bundles Entries crossing from the payload into the manifest are reported as unreadable. Synthetic regression a_member_cannot_borrow_bytes_from_the_manifest in the formats crate.
Watched descendant regression A guarded Rust parent starts the heartbeat child in its inherited process group/job. No shell quoting is involved. The watched launch is stopped before missing startup markers can fail an assertion macOS regressions pass for descendant shutdown, startup-timeout cleanup and direct ignored-fixture runs without guards. Windows execution of this replacement remains pending; the prior shell fixture failed there. The platform suite still has the separately tracked preview-connection fixture failure
Disabled chat backends Naming a backend that is off refuses chat and either side of compare with a settings error and guidance, before API or coding-agent setup Isolated hub regressions for disabled API and agent backends, both compare positions, and enabled/automatic controls. Invalid tunnel settings detect API setup before the guard. No live provider or agent was used
Request-based project kinds Low-level tools and media players keep the app target when “level” or “player” describes the tool. Explicit game requests and game engines still select the game target Request-classification regression cases
Runner-owned app windows Runtime capture tries the launched process and its descendants; the captured window owner's PID is also used for the UI tree. Unrelated processes with matching names are excluded. Process discovery has a deadline, output cap and candidate limit Hermetic regressions cover runner/child/grandchild ownership, unrelated windows, direct launches, cycles, malformed rows, caps and errors. A macOS process snapshot finds an owned child without opening a window. Windows and real Go GUI capture have not been run
New-project toolchains New Python, Go, .NET, Maven, Gradle and Make projects use the same build catalogue as existing projects (engine/src/toolchains.toml). A Python project without a root entrypoint can start its one installed [project.scripts] console wrapper from its virtual environment. Shared launch recipes let screenshots, self-tests and Play start Python main.py, app.py or __main__.py, a single Python package with a <name>/__main__.py as python3 -m <name> in a project with a Python marker, Go with a root main.go or a single cmd/<name>/main.go, one root .csproj, and the single runnable jar (its manifest names a Main-Class) a Maven (target/*.jar) or Gradle (build/libs/*.jar) build left, with java -jar. Maven builds with package -DskipTests, so that jar is this build's. Python uses a project-local virtual environment when present, resolves its executable to an absolute path even for relative project folders, and forces fresh syntax compilation; .NET passes app options after --. Manifest markers take priority over standalone Python files. Runtime window-capture requests normalize relative project and runner paths to absolute paths. Godot and Electron receive an absolute project path when launched from a relative workspace. Existing packaged programs, Rust, Electron and Godot keep launch priority. Multiple .csproj, package or runnable-jar matches or a capped scan do not choose a project. Other layouts still need a packaged program or another launch recipe Catalogue and launch regressions cover argv boundaries, ambiguous entrypoints, scan limits and Windows/local interpreter selection, including relative project folders and unchanged argument boundaries. Capture-request tests cover relative placements and PATH results, local interpreters and optional UI-tree output without opening a window. An owned interpreter stand-in runs the full new-project build/screenshot path, rejects failed builds, and verifies a failed screenshot cannot reuse an old PNG. An opt-in real Python 3.15.2 fixture on macOS passes build/screenshot checks, ignores invalid virtualenv code, and rejects a syntax error even when its mtime matches the cached version. Without compileall -f that same syntax-error probe incorrectly exits zero. Real Go/.NET/Maven/Gradle runs, Windows and GUI apps have not been verified for this change; java -jar on a real jar has not been run
macOS optional UI tree and screenshots runtime_ui_read with accessibility: false skips the tree and its permission check, returns empty nodes without truncation, and records the skipped read (#307). Walkthroughs still require Accessibility. With screenshot: true, macOS 14+ returns one owned-by-pid window as PNG/base64, restricted by window_id when supplied; without it, the first matching on-screen window. Images are limited to 2048 px per side and 6 MiB PNG. Combined JSON stays within the 16 MiB helper output cap; oversized trees retain a prefix with explicit truncation and partial coverage while preserving the image. Missing Screen Recording permission, a missing window or a capture failure is an explicit screenshot limitation with partial coverage (#248). Denied Accessibility permission returns a tool error before capture when the tree is enabled (the default); set accessibility: false to skip the tree. Permission dialogs are never opened Synthetic Swift serializer regression covers combined tree/image overflow, escaped Unicode values, a single oversized node, an oversized image, and unchanged small/skipped trees. Engine regressions compile/run the real Swift helper: skipped trees at node limits 0/1, screenshot-off control, and impossible-window screenshot errors propagated to evidence. Live helper probe on macOS 27.2 captured only an owned AppKit fixture: valid 320 × 192 PNG (14,400 bytes), matching window id; screenshot-off returned no image/error. No granted-permission tree read, walkthrough, macOS 14 run or MCP transport run
CPIO member names and trailers Keep incomplete pathnames and invalid end markers out of a completed cpio inventory. Extra NUL padding in a name remains valid. Regression cases added: Malformed names, padded names, nonempty trailers and truncated final padding.
DNS service records and address announcements SRV, SOA and CAA answers expose their wire fields. Internet addresses have checked widths. Truncated replies retain their complete records, and unsolicited address announcements keep their owner. Synthetic DNS and mDNS captures cover bounded fields, compressed names, empty UPDATE prerequisites and legacy replies.
DNS question boundaries A question is retained only when its name, type and class are complete. A missing class byte marks the DNS message incomplete; preceding complete questions remain available, and incomplete questions do not enter the query inventory Four packet regressions cover both truncation lengths, multiple questions, complete class values and the capture summary. No live capture was used
Reject impossible IPv4 header and total lengths IPv4 decoding rejects impossible header lengths and reports incomplete base headers or options. Synthetic byte fixtures in pcap_ipv4_lengths integration regressions. Cover 10–19 captured header bytes, total lengths below IHL, missing options, complete options, truncated transport headers with readable ports, and a cut UDP payload with both ports and its captured length preserved.
Validate the version in IPv6 frames IPv6 decoding checks the packet version before reporting IPv6 facts, including captures declaring raw IPv6; explicit raw IPv4 likewise uses IPv4 validation. Synthetic byte fixtures in pcap_ipv6_version integration regressions. Cover incorrect versions behind the IPv6 EtherType, mismatched explicit raw IPv4 and IPv6 link types, matching explicit and generic raw packets, and valid IPv6 traffic-class bits.
Stop decoding extension headers inside noninitial IPv6 fragments Noninitial IPv6 fragments no longer supply fabricated extension or transport headers. Synthetic byte fixtures in pcap_ipv6_fragments integration regressions. Cover payloads resembling a second fragment header or destination-options header, plus valid first and atomic fragments.
Enforce the expanded DNS name wire-length limit DNS names obey the 255-byte expanded wire limit. Invalid name-valued RDATA marks parsed answers incomplete; legal empty ANY/NONE UPDATE prerequisites remain supported. Synthetic byte fixtures in pcap_dns_name_limit integration regressions. Cover plain and compressed names at the wire limit, literal-prefix compression overflow in questions and NS/CNAME/PTR/MX records, record boundaries, root names, and legal empty UPDATE prerequisites followed by another record. Coverage is limited to the parsed questions and first 64 answer or UPDATE prerequisite records.
Report truncated DNS TXT strings as incomplete TXT validation covers at most 64 parsed answers, or prerequisites for DNS UPDATE; authority and additional records are not inspected. Empty ANY/NONE UPDATE prerequisites with zero TTL and empty TXT records for wire-identified DNS-SD instance owners in ordinary multicast/unicast DNS are retained. Synthetic byte fixtures in pcap_dns_txt_lengths integration regressions. Cover a cut first string, a cut later string, a missing string body, and valid empty or multiple strings. Review regressions preserve empty UPDATE prerequisites and following records, while checking opcode, class, TTL, and truncated-string boundaries. DNS-SD cases cover known answers, cache-flush records, compressed owners, literal dots and case, plus ordinary/invalid owners and nonempty truncation.
Indexed source maps Reject malformed section tables and offsets, preserve the boundary of an unfetched external map, and reject descending section offsets. Regression cases added: Index shape, offsets, external boundary and resumed lookup fixtures.
Inline maps with URL fragments Ignore a data URL's fragment during decoding, preserve percent-encoded number signs in the data, and accept case-insensitive data and base64 markers. Regression cases added: Raw and encoded fragments, mixed-case markers, queries and non-data schemes.
TLS ClientHello offers Packet inspection validates session IDs, cipher-suite and compression vectors, SNI, ALPN and supported versions. It keeps the first copy of a repeated extension, distinguishes reserved GREASE from unknown versions, and checks ALPN beyond the display limit. Synthetic captures exercise invalid offers and complete legacy and modern handshakes.
Read HTTP Host fields only from the header section HTTP Host values come only from complete request header lines. Synthetic byte fixtures in pcap_http_host_boundary integration regressions. Cover forged Host lines in bodies, invalid UTF-8 before Host, mixed-case field names, and incomplete header lines.
Keep capture flow timestamps in chronological order Flow time ranges use the earliest and latest available timestamps. Synthetic byte fixtures in pcap_flow_time_range integration regressions. Cover out-of-order timestamps and a flow that starts in an untimestamped simple packet block.
Capture timestamps and malformed packet records Classic captures omit timestamps with out-of-range fractions. Fine pcapng resolutions preserve the interface offset. Rejected packet records share the scan budget and report bounded diagnostics. Synthetic classic pcap and mixed-section pcapng fixtures cover both time units, damaged block lengths, undeclared interfaces and repeated iteration.
Reject incomplete simple packet block payloads Simple packet blocks validate captured lengths and exclude alignment padding. Rejected lengths count toward the packet scan limit and produce one summary warning when the walk ends. Synthetic byte fixtures in pcapng_simple_payload integration regressions. Cover short payloads, excess payload bytes, unlimited snaplen, legitimate snaplen truncation, alignment padding, bounded warnings, and later valid frames. Unit regressions exercise rejected-only and mixed packet budgets, exact EOF, and repeated iterator exhaustion.
Keep ZIP directory entries within the declared directory ZIP central-directory entries stay within the declared directory. Synthetic byte fixtures in zip_directory_bounds integration regressions. Cover a short declared entry after a valid entry even without a signature, fields borrowing end-record bytes, an oversized directory, both self-extracting offset conventions, and a trailing directory signature.
Filesystem and archive recovery JFFS2 zero extents and nodes, ROMFS payloads and pointers, cramfs names, SquashFS tables and PAX overrides stay within their recorded sizes and recovery budgets. A truncated SquashFS metadata block marks the image incomplete and leaves earlier blocks readable. Synthetic filesystem images and tar archives cover truncation, oversized payloads, padding and normal records.
Refuse split ZIP archives without their other volumes ZIP archives requiring other volumes are reported as unsupported. Explicit classic directory sizes and offsets must agree with ZIP64 unless set to their own sentinel. Synthetic byte fixtures in zip_split_volumes integration regressions. Cover classic disk markers and counts, ZIP64 locator and record fields, conflicting classic/ZIP64 entry counts, entry disk sentinels both alone and after the sizes and local offset, and valid single-volume controls with mixed count sentinels. Additional regressions cover explicit directory-bound conflicts and each independently saturated end field.
Unity floating-point textures The PNG exporter reads RHalf, RGHalf, RGBAHalf, RFloat, RGFloat and RGBAFloat. RGB is converted from linear light to 8-bit sRGB, alpha stays linear, and scalar textures are shown in grey. Synthetic half- and full-precision textures cover every channel layout, short mips, row order, non-finite values and clipping.
Check Unity bundle blocks against their declared output lengths Unity bundle pieces must match their declared decoded lengths; LZMA must finish within the supplied compressed piece. Synthetic byte fixtures in unity_bundle_decompressed_length integration regressions. Cover stored pieces that are short or long, LZ4 and LZ4HC size mismatches, LZMA with or without end markers, empty and short zero streams, bounded dictionary/output growth, oversized dictionary properties, and truncated or trailing compressed bytes.
ZIP directory attributes Read the DOS/Windows directory bit and Unix directory file type even when the ZIP name has no trailing slash. Regression cases added: DOS, NTFS and Unix directories with regular-file and symlink controls.
Locate Unity bundle metadata within the declared bundle size Unity bundle metadata placement respects the declared bundle extent. Synthetic byte fixtures in unity_bundle_declared_size integration regressions. Cover versions 6 through 8, front and trailing tables, padding, appended bytes, invalid extents, and header-only prefixes of larger bundles.
Keep Unity bundle blocks inside the data region The shared table parser refuses compressed block totals crossing the trailing table or the declared bundle end before listing or extraction can read block contents. Synthetic unity_bundle_data_region regressions cover versions 6–8, both table positions, data alignment, appended bytes, cumulative sizes above 32 bits, exact fits, spare bytes and empty blocks. No real game bundle was run for this correction.
Reject Unity serialized objects outside their declared file Unity serialized object ranges must fit the declared file. Synthetic byte fixtures in unity_serialized_object_ranges integration regressions. Cover offset and end overflow, ranges crossing the file boundary, both byte orders, valid existing objects, and empty objects at EOF.
Preserve compression method slots in Unreal pak indexes PAK compression names retain their original method numbers. Synthetic byte fixtures in unreal_pak_compression_slots integration regressions. Cover interior and leading empty slots in plain and packed indexes, plus unchanged contiguous method tables.
Require complete terminators in Unreal FString values PAK and IoStore strings require complete terminators. Synthetic byte fixtures in unreal_fstring_terminators integration regressions. Cover missing ANSI and UTF-16 terminators, zero-length strings, terminated empty strings, Unicode names, and the shared IoStore path.
Count every compression block spanned by an IoStore chunk IoStore stored-size totals include every block touched by a chunk. Synthetic byte fixtures in iostore_unaligned_chunk_blocks integration regressions. Cover unaligned chunks spanning two or three blocks, aligned chunks, exact-boundary endings, and empty chunks.
Reject truncated IoStore fixed headers IoStore parsing rejects incomplete fixed headers. Synthetic byte fixtures in iostore_complete_header integration regressions. Cover every truncation in the reserved header tail and complete fixtures for the supported header versions.
Reject invalid marshal long integer digits Python marshal long integers reject invalid digit encodings. Synthetic byte fixtures in pyc_long_limb_validation integration regressions. Cover positive and negative invalid digits, leading zero digits, canonical zero, ordinary integers, and valid large integers.
Check expanded RGBA image sizes before allocation Pixel decoding checks expanded RGBA size, applies a caller-selected output budget (256 MiB by default), and reserves output fallibly. Packed 16-bit layouts decode without an intermediate image allocation. Synthetic byte fixtures in pixel_rgba_output_overflow cover budget rejection before source access, exact output limits, caller overrides, overflow, ordinary and packed pixels, partial blocks, empty pictures, and truncated input. Large-dimension checks use empty source data; a 32-bit expansion-overflow regression is included.
Safetensors header and payload coverage Reports non-string metadata, oversized headers, invalid packed tensor lengths, overlapping ranges, gaps and unclaimed trailing data. Summary text uses the same bound as the metadata view. Header-only fixtures retain reordered and empty tensor controls.
Count empty tensor shapes consistently across axis orders Zero-sized tensors have zero elements regardless of dimension order. Synthetic byte fixtures in tensor_zero_dimension_product integration regressions. Cover zero-dimension permutations in safetensors and GGUF, scalar shapes, nonempty tensors, and shapes with genuine multiplication overflow.
Find APK signatures through valid ZIP comments APK signing-block lookup validates EOCD framing and central-directory bounds, prefers recoverable signers over empty or unreadable decoys, and warns when distinct readable signing blocks remain ambiguous. Directory, pair and signer probes share a scan-wide record budget; bounded caches reuse directory prefixes and physical pair and signer records while checking each candidate’s own extent. Comment-boundary regressions cover nested empty, unknown and unreadable blocks, a fully framed spanning pair, ambiguous readable blocks, empty signed ZIPs and thousands of candidates sharing the genuine directory. Existing damaged-block recovery and directory-framing tests remain; unit tests cover probe recovery, parser limits, directory-cache isolation, optional tails, repeated signer probes with shorter and longer bounds, and work/cache exhaustion.
Keep Mach-O load-command facts within their command Mach-O command facts stay inside their declared command boundaries. Synthetic byte fixtures in macho_load_command_framing integration regressions. Cover undersized build commands, a shortened command region, tool entries spilling into the next command, truncated section arrays in both parsers with later complete commands preserved, and complete commands in both byte orders.
Keep Mach-O function starts within their declared payload Mach-O function-start deltas stay within their payload and cannot wrap addresses. Synthetic byte fixtures in macho_function_starts_payload_boundary integration regressions. Cover a continuation byte at the payload end, retained complete deltas, address overflow, and valid multibyte deltas with a terminator.
Source map position deltas Decode the reserved signed minimum correctly, reject magnitudes past the 32-bit range and accept zero-extension groups without overflowing shifts. Regression cases added: Signed limits, numeric overflow, redundant zero groups and accumulated generated positions.
Keep code-signature children within their declared superblob Code-signature metadata and engine verification reads stay inside the declared superblob. Stored page and special-slot hashes also stay inside their own CodeDirectory; invalid relative offsets leave them unchecked. Declared special slots whose stored hashes cannot be read remain visible as not-checked with stored: null. Synthetic codesign_superblob_length_boundary regressions cover an external CMS blob, a cut index, a short header, and a complete signature. Engine signature regressions keep appended entitlements and stored page hashes out of verification, with complete-signature and genuine CMS controls. An engine regression covers all five reported special-slot identities with unreadable stored hashes. Engine regressions also cover stored hashes past a CodeDirectory but inside the superblob, and special-slot offsets before the CodeDirectory.
Code-directory flag names code_directories[].flag_names use the bits and names codesign -d shows (hard, kill, expires, restrict, enforcement, library-validation, runtime, linker-signed, host, adhoc) Unit test against codesign's output for each flag; flag values of the signed Mach-O files on a Mac compared with codesign -d
Keep PE optional-header reads within the declared header PE optional-header reads respect the declared header size. Synthetic byte fixtures in pe_optional_header_framing integration regressions. Cover short fixed headers, partial directory entries, zero or one directory in both PE variants, and unused bytes before the section table.
Keep PE resource metadata within the resource directory PE resource metadata stays within the declared directory and the contiguous range selected by the existing RVA mapping, including raw extents, section priority, header-prefix boundaries, and 32-bit address limits. Resource names must fit their full declared UTF-16 span before the existing 4096-unit output cap is applied. Synthetic byte fixtures in pe_resource_directory_boundary integration regressions. Cover escaping subdirectories and names, partial data-entry records, a valid resource whose payload is addressed separately from its metadata, complete versus directory-truncated names above the output cap, names crossing a section's raw extent with the resource root at its start or inside it, metadata in the header prefix, mapping changes caused by section priority, zero-extent and lower-priority controls, and the end of the RVA address space.
Certificate verification inputs Read the algorithm OID only at the start of its sequence, require octet-aligned nonempty keys and signatures, and check the issuer and subject name tags before linking certificates. Regression cases added: Field mutations on generated certificates and public keys, and an out-of-order algorithm identifier.
Keep Go function tables and names within their section Go function tables and names respect every containing file-backed section during scan recovery, including unnamed and overlapping sections. Recovery outside known sections keeps the whole-file extent. A named table with no readable functions allows bounded recovery while retaining its partial evidence if no replacement is found. Synthetic byte fixtures in go::tests unit regressions. Cover Go 1.16 and 1.20 table entries, unterminated names, public inspect()/functions() recovery from truncated or empty named sections and interior headers, unreadable named tables with or without a readable interior replacement, unnamed entry/name boundaries, overlapping or expired extents, and recovery outside known sections or without section headers, with complete-table controls.
Preserve complete Unicode characters in shortened .NET strings .NET user-string limits preserve supplementary Unicode characters. Synthetic byte fixtures in dotnet_user_string_surrogate_limit integration regressions. Cover supplementary characters at several limits, a zero-character limit, and unpaired surrogates followed by valid characters.
Locate ELF core mapping names after the complete declared table ELF core filenames follow the full declared mapping table. Synthetic byte fixtures in elf_core_file_name_count_cap integration regressions. Cover 65,537 declared mappings with capped output, an impossible declared table, and a small complete mapping table.
Keep DOS relocations inside the declared executable header DOS relocation records stay inside the declared MZ header. Synthetic byte fixtures in dos_relocation_header_boundary integration regressions. Cover records extending into the load module, a partial final record, and complete records ending exactly at the header boundary.
Java decompilation java_vineflower_decompile decompiles a real JAR to source with the pinned Vineflower 1.12.0, run through the configured Java Live run on Linux x86-64 (OpenJDK 21.0.12.1) against Apache Commons IO 2.16.1 (497 KB, 374 entries): 253 source files, exit 0; org.apache.commons.io.FileUtils returned 1,350 lines with the class and its file-reading methods present. The engine install matched the pinned SHA-256. Not checked: Windows and macOS, a .class input, or a second JAR
Conversation width Agent paragraphs, inline code and fenced code stay within the message column, including glossary terms followed by long file links (#523) UI regression checks painted text and subsequent answers against the composer bounds in Project and Ask at 1920 × 1032 and 1280 × 820; Unicode/formatted glossary hover check
Settings saved on exit Pending app settings merge the session's latest AI table when its guard is available. A busy session defers non-AI edits in config.pending.toml without waiting for the tool; startup recovers them with the latest committed AI table Isolated child-process regression exercises idle and busy exit saves, a late AI commit, startup recovery and pending non-AI edits; engine tests cover sidecar migrations and damaged/newer files. No live desktop shutdown was exercised
Atomic-write temporary files Reserve short temporary names distinct from the destination and its filename aliases, with exclusive creation and bounded collision retries. Private files have owner-only Unix permissions from creation; cleanup removes only a file reserved by the current write. Original implementation 5f0f1ce2 passed full Linux CI. The review follow-up preserves collision, symlink, inherited-permission, retry-limit and cleanup assertions, and adds a bounded probe for a valid long name, direct creation-permission checks and deterministic destination-alias exclusion checks. 27e5d631 passed full Linux CI.
SQLite payload limits Capped records retain column positions, disclose partial TEXT and BLOB values, omit incomplete BLOB hashes, and report partial coverage with read notes Hand-built overflow-page regressions for five oversized records (including WITHOUT ROWID in declaration order) and two controls; table and index engine coverage and limitation regressions
SQLite added columns Short records include missing trailing fields using literal column defaults, or NULL when absent; unsupported default expressions produce NULL with a row note. A default is read with its column's affinity, as SQLite reads it: a TEXT column's DEFAULT 5 is '5', an INTEGER column's DEFAULT '7' is 7, and a BLOB or untyped column (or a STRICT table's ANY column) keeps the literal as written. Stored fields and records longer than the schema retain their values. Defaults are filled before restoring rowid aliases Hand-built parser regressions and an engine tool test cover added-column defaults, rewritten records and short records with a rowid alias, including a missing alias field; defaults of every affinity (rowid, WITHOUT ROWID and STRICT tables, UTF-8 and UTF-16le) compared with the official SQLite library on generated files
Ghidra and closing the app Closing the app stops an analysis a build started, and waits for it to end, so java.exe isn't left running (#946). An app that crashes or is killed can still leave one (#951). Deep mode doesn't analyse an Electron program's runtime, whose logic is in app.asar (#947) Stopping tested with a waiting analysis; not run against a live Ghidra A Ghidra with no decompiler program for this computer, as public downloads have on macOS, is refused before the analysis starts, with the command that builds one.
Gemini tool calls A tool call's extra_content (Gemini's thought signature) goes back with it unchanged, so Gemini 3 builders get past their first tool call; errors Gemini wraps in an array show their message (#978) Unit-tested; not run against the live API
OpenCode models and thinking OpenCode V2 locally and over SSH; Settings → AI lists only that instance's enabled chat models and supported Low/Medium/High/Xhigh/Max variants. Selection is validated and saved through UI, CLI and ai_models_list / ai_model_set. Explicit selections run natively with the Craft Anything MCP server (local runs, and over SSH: one ssh run checks craft-anything-cli on the host's PATH and writes the config on the host, ~/.cache/craft-anything/, mode 600). Discovery, including the model check before each turn, uses a private server too (--standalone, unless a --server is chosen), so it never starts the shared service that resumes unfinished sessions (#1115). See OpenCode. Stand-in catalogue/process, persistence, remote-command and UI tests; local live catalogue checks (34 models, all five depths represented). Regression checks route explicit selections natively and parse V2 tool events. Live (2026-11-04, Windows, OpenCode 2.2.5, opencode-go/deepseek-v4.1-flash): a --standalone run connected the server (38 tools) and called core_session_show. The SSH path is covered by a POSIX-shell regression test (probe fails fast without the helper; config written byte-exact, mode 600, atomic rename) and was exercised against a localhost SSH host; it has not been run with a live agent over SSH. No paid generation used. Live (2026-11-08, Linux, OpenCode 2.2.5, a local Qwen model): before discovery used a private server, a build's model check started the shared service, which resumed a session left unfinished days before and went on editing another project. Live (2026-11-08, Linux, OpenCode 2.2.5 and 2.2.6, a local Qwen model through an OpenAI-compatible server): "a scientific calculator" reached Ready twice (one run, stopped by its time limit, finished with --resume); our tools reached the builder through 2.x's execute, and it opened its own screenshots and a 3840×2400 reference picture with OpenCode's read tool and acted on what they showed (a key that did nothing; a recoloured icon)
Claude desktop app without Claude Code When the claude command isn't found but the Claude desktop app is (Windows: the Store package's claude-desktop app alias, else its package folder, or the older installer's AnthropicClaude folder; macOS: Claude.app), the builder dialog under "No coding agent was found" and ai detect (on stderr) say the desktop app is installed but building needs Claude Code, installed apart (#259). The hint stays when the only suggestions are unchecked agents from ~/.ssh/config. A claude program inside the desktop app (on PATH) is never offered or started as Claude Code: detection, the hint and a run's program look through one cli_agents::find_program; with only the desktop app there, a run, ai test and the builder check fail with "Claude Code isn't installed" instead of starting it, also when claude (by name or as the desktop app's own file) is the saved program; a link to the app counts as the app, and a name saved on purpose (claude.cmd) that starts Claude Code itself is kept. Typed as DetectHint from AiHub::detect_hints A regression finds the app in temp folders laid out as each Windows installer leaves it, and nothing on Linux; a UI test shows the hint in the dialog, with only SSH suggestions too, and not once an agent here is found; a test passes over the desktop app's claude.exe on a search path, and program_of with the app first, the real one first, a saved path that's gone, and the app alone, and a saved claude by name or as the app's file, a saved wrapper name kept, and a link to the app passed over (links checked where they can be made: not on Windows without the right). On Windows 10 the real Store package's alias was found. Not checked: macOS, the older installer, and a computer with no claude installed
Missing program paths A program started by its path (a saved agent program, for one) that has no file there is reported with that path, as possibly moved by an update, with reason path_missing, instead of "isn't installed or isn't on your PATH"; a bare name still speaks of PATH. A relative path is looked up where the program starts (on Unix, its working folder), so a script there whose interpreter is missing isn't called a path with no file. It stays a missing program (EngineMissing), so builder turns aren't retried (#721). ai test names the agent program it ran and the saved one it replaced (program, saved_program_replaced), and doctor says a saved path has no program there a_saved_program_that_is_gone_is_named_by_test_and_doctor runs both with a removed path. A regression starts a program at a path with no file on Windows 10 and checks the message, remediation and reason, with a bare-name control; on Linux (Docker), a relative script with a missing interpreter started in its folder, through Process and Launch. Not checked: a real Codex desktop update, or the app's Settings screen with a stale path
npm agents without Node on Windows Programs are also looked for in nvm for Windows' version folders (NVM_HOME, else %APPDATA%\nvm, newest first, after PATH), so an npm shim such as claude.cmd finds Node when no nvm use link exists. When a shim's interpreter is still missing, starting it fails with EngineMissing, reason interpreter_missing, naming node and nvm use, instead of Rust's "batch file arguments are invalid" On Windows 10 (Rust 1.99.1): unit tests for version-folder listing with nvm's own files beside the versions, the missing-interpreter check (no Node, Node on the search path, Node beside the shim) and the error's fields; the existing shim tests, including a real multi-line prompt through Node, and the platform crate's 70 tests pass. The failure was seen with Craft Anything 0.4.0 (Claude Code 1.0.96 npm shim, nvm with no version in use). Not checked: the fixed desktop app or CLI on that machine, and a build through a shim found only in nvm's folders
Mach-O Objective-C pointers Chained offsets mapped only into file-empty __PAGEZERO reach the image-base fallback; pointer candidates must be backed by file bytes Synthetic thin and fat Mach-O regression, plain-pointer and authenticated-rebase controls, null and unmapped-pointer checks. Real binaries were not checked for this correction
Mach-O entry points The LC_MAIN file offset maps through the segment whose file bytes hold it, so a segment with no file bytes (__PAGEZERO, or a __DATA of only zero-fill sections, which also records file offset 0) never takes the entry; an offset outside every segment's file bytes gives no entry Synthetic regression. All 3,205 executable slices of 1,794 Mach-O files on macOS 15.7 (/bin, /sbin, /usr/bin, /usr/sbin, /usr/libexec, app bundles) match otool -l (__TEXT address plus entryoff, or the LC_UNIXTHREAD program counter); 270 slices in 153 files read the wrong address before
Runtime UI evidence A denied macOS Accessibility permission is an error (no_permission, naming System Settings → Privacy & Security → Accessibility), not a successful read of an empty tree (#240). Any other refusal from the helper is also an error, never nodes: [] Unit regression maps the helper's refusal object, keeps a genuinely empty tree a success, and covers the unknown refusal; live runtime_ui_read --pid 1 on macOS with the permission denied returned the structured error. The granted-permission path was not re-run for this correction
XML property-list documents Requires a closed plist with one root, preserves scalar whitespace, rejects stray content and invalid encodings, and consumes whole processing instructions and internal DTD subsets. XML root, byte-order and processing-instruction fixtures.
Apple app graphs Selecting a macOS bundle recognises its root-relative Contents/Info.plist and retains its service/extension type; nested XPC bundles appear in services and as xpc-service graph nodes, including their executables when hosted in frameworks Synthetic inventory tests, including parent-directory and flat bundle layouts, selected services/extensions, framework-hosted service executables, and bare-program controls. Ordinary selected directories with Contents/Info.plist need an Apple bundle suffix; archives retain layout-based recognition. Framework libraries and dylibs stay excluded from executables. Real app bundles were not checked for this correction
Asset catalog key formats (apple_assets_list) A catalog built for a system older than one of its key attributes, which actool marks with a stand-in in KEYFORMAT and the real attribute in KEYFORMATWORKAROUND, takes the real one, so display gamut is named display-gamut in the key format and rendition keys instead of placeholder Hand-built fixture; 738 catalogs on macOS 15.7 and one built by actool for macOS 10.11 compared with assetutil --info. iOS catalogs were not checked
Chinese UI Simplified (zh-hans) and Traditional (zh-hant) Chinese in Settings → General → Language; System chooses a supported OS language, otherwise English. Both catalogs cover UI controls and tool titles; translated titles are searchable. Raw tool data, AI text, logs, CLI/MCP and the separate browser viewer keep their original text. See localisation. Catalog integrity and locale-resolution tests; cargo xtask i18n-coverage; isolated UI language-switch test. Platform visual checks are recorded separately.
Android binary XML event framing Incomplete events and malformed attribute layouts set the truncation flag. Namespace data follows the declared node header. Parent, child, extended-header, stride and typed-value byte fixtures.
Engine 300 engine tools (320 with the AI and setup layers') across native, managed, Java, Android, Apple, JS/Electron, web, firmware, packets, databases, game archives and assets; see tools.md and tool-status.md. A saved result can be narrowed without running again (core_evidence_browse keeps the rows matching given field values, cut to chosen fields) A functional audit that ran every tool on real inputs on Windows, plus 600+ unit and integration tests
Tool argument correction Shared parameter parsing keeps schema types strict and reports the rejected value's JSON Pointer when known, the original type error and guidance to correct the call. Unknown locations are null; a root failure uses the empty pointer Parser regressions cover string/array mismatches, nested indices, escaped keys, oversized paths, enum locations, defaults and strict fields. Shared engine dispatch is checked for Agent, MCP and CLI callers: rejected arrays create no record, and corrected input creates one. No live Qwen or Ollama build was run for this correction
German UI German (de, informal "du") in Settings → General → Language; System picks it for a German OS language. The catalog has the same keys as the Chinese ones. Drafted with an AI, not yet reviewed by a native speaker. Requests such as "Ein einfaches Snake-Spiel" or "Eine Website für …" keep their project kind. See localisation. Catalog and locale tests, key-set comparison with the Chinese catalogs, the isolated language-switch test, a kind-detection test; fmt, clippy, layers, locks and secrets are clean. Not checked: how the German texts look in the running window (length, line breaks), and the de.tsv wording by a native speaker.
Estonian UI Estonian (et) in Settings → General → Language; System picks it for an Estonian OS language (et, et-EE). The catalog has the same keys as the other catalogs. Drafted with an AI from the English source; corrections from native speakers are welcome. Requests such as "Lihtne usumäng" or "Veebileht minu …" keep their project kind. See localisation. Catalog and locale tests, key-set comparison with the other catalogs, a kind-detection test, cargo xtask i18n-coverage (0 missing), a --lang et Settings snapshot (the text fits at 2160×1350); fmt, clippy, layers, locks and secrets are clean. Not checked: the other screens in the running window and platform dialogs.
Georgian UI Georgian (ka) in Settings → General → Language; System picks it for a Georgian OS language. The catalog has the same keys as the other ones. Written with Claude Code from the meaning of each English string; terminology and doubtful strings decided by a native Georgian speaker (@devius). See localisation. Catalog and locale tests, key-set comparison with the other catalogs, the isolated language-switch test, the craft-fonts glyph test with a Georgian line. Not checked: how the Georgian texts look in the running window (length, line breaks).
Spanish UI Spanish (es, informal "tú", Mexican vocabulary) in Settings → General → Language; System picks it for a Spanish OS language. The catalog has the same keys as the Chinese ones. Register and glossary chosen by a native speaker, the text drafted with AI assistance. Requests such as "Un juego de serpiente sencillo" or "Un sitio web para mi panadería" keep their project kind. See localisation. Catalog and locale tests, key-set comparison with the Chinese catalogs, a kind-detection test. Not checked: how the Spanish texts look in the running window (length, line breaks).
Italian UI Italian (it, informal "tu") in Settings → General → Language; System picks it for an Italian OS language. The catalog has the same keys as the others. Drafted with an AI, not yet reviewed by a native speaker. Requests such as "Un semplice gioco del serpente" or "Un sito per …" keep their project kind. See localisation. Placeholder and ellipsis check against the English keys, and a kind-detection test. Not checked: the running window (length, line breaks), a native-speaker review, or the full UI catalog test suite.
Vietnamese UI Vietnamese (vi, Tiếng Việt) in Settings → General → Language; System picks it for a Vietnamese OS language (vi, vi-VN). The catalog has the same keys as the Chinese ones. Drafted with an AI from the English source, not yet reviewed by a native speaker. Requests such as "Một trò chơi rắn săn mồi" or "Một trang web cho …" keep their project kind. Letters with stacked marks need craft-fonts (releases and CI have it); they come from Noto Sans CJK, not DM Sans. See localisation. Catalog and locale tests, key-set comparison with the Chinese catalogs, the isolated language-switch test, a kind-detection test, cargo xtask i18n-coverage (0 missing); the craft-fonts script test with every Vietnamese letter, and a --lang vi Settings snapshot on macOS with the pinned craft-fonts; clippy, layers, locks and secrets are clean. Not checked: the vi.tsv wording by a native speaker, and the other screens in the running window (length, line breaks).
Java class usage java_class_users_find includes the component class of multidimensional object arrays; primitive-array descriptors do not match an unrelated class with the same descriptor letter Synthetic class files parsed by the built-in reader: one- and two-dimensional allocations, class names beginning with L, primitive arrays, hit limits and method filters; formats tests. This correction was not checked with javac output or a JVM
Keyed-archive reference graphs Object rows expose edges from arrays and UID aliases. Projection follows inline dictionaries, arrays and aliases, including cycles. Repeated scalar references spend a shared byte budget. Binary/XML fixture and nested object, alias and cycle regressions.
Single-file apps and game files core_packed_files_list and core_packed_files_unpack read Bun and Node.js single-file programs, .NET single-file apps, PyInstaller and Godot packs through one seam (formats::packed); formats_bytecode_show reads Python bytecode, game_unity_code_names_show Unity IL2CPP metadata, formats_ai_weights_show GGUF and safetensors headers. app_folder_explain says what an install folder is made with and what to run next Unit tests with damaged files. Real files: a 279 MB Bun program, Node blobs, PyInstaller programs (Python 3.9, 3.14), .NET 8 single-file apps (macOS, Linux, Windows, compressed), Godot 3.6, 4.3 and 4.5 packs, 214 Python modules against CPython's own reader, a GGUF and a safetensors file, about 25 installed Mac apps. IL2CPP on synthetic files only
Source map lookup on long lines Binary-search sorted section starts and segment columns. A lookup examines only the matching positions, while preserving duplicates and unmapped boundaries. Regression cases added: A repeated lookup fixture and equal-column and unmapped boundary cases.
esbuild module dependencies Recognised CommonJS and ESM wrappers keep their dependency edges after identifier minification; semantic bindings distinguish shadowed and reused names, and repeated calls produce one edge. Ordinary calls do not consume the 4096-wrapper dependency budget, including when the wrapper is declared later 50 JS tests pass. Synthetic regressions cover short names, forward declarations, both wrapper kinds and function/arrow bodies, shadowed parameters, reused names, unrelated calls and duplicates. Public analysis fixtures include 4096 distinct ordinary calls before a wrapper dependency and 4097 real wrapper dependencies to check the cap and first-seen order. No real minified application was run for this correction; sources above the existing semantic-analysis size limit retain name-based resolution
Program facts across builds native_library_calls_list (delay-load too), native_offered_symbols_list, native_publisher_show (checks the file hash and the signature, not Windows trust), app_builds_line_up pairs functions across two builds and says how, native_source_folder_write writes pseudo-C to a folder and picks up where it stopped, android_components_list Unit tests. Real PE, ELF and Mach-O files; two builds of a 276 MB program; a signed Microsoft DLL; Android components from one real APK, spot-checked
ARM32 value flow A32 and Thumb calls define ARM scratch registers, and word results flow through r0 into returns in native_value_flow_show. Conditional A32 calls retain the earlier value when skipped and a possible returned result; calls to known non-returning targets keep only the skipped path Synthetic instruction fixtures for leaf results and indirect calls in both modes, with AArch64 and x86-64 controls; direct and indirect A32 conditional calls within and across basic blocks, including a named abort target and unconditional controls. This correction was not checked on real ARM binaries or devices
Stand-in backends web_standin_build turns a HAR into standin.json (secrets dropped, varying path parts templated); web_standin_start answers from it on loopback; web_standin_show lists what it had no answer for. A 304 without a usable cached body is counted at build time and skipped during replay; if its matching group has no usable answer, requests get a 404 with cached_body_unavailable, also shown in the request log. Writes replay what was recorded and don't change later reads. Older saved query variants keep explicit empty pairs when credential rules are reapplied; raw separators remain ignored and the 200-pair limit matches capture. App maps list GraphQL and tRPC operations; web_walkthrough_check checks a scripted session without a browser Unit tests, real loopback requests, and a run with curl on a hand-written HAR. The 304 correction passes 99 analysis tests and a real-loopback regression, covering mixed samples, omitted bodies, matching boundaries and existing v1 files. Hosted CI for #543 also passed the full engine tests and workspace gates. Public capture/replay regressions cover legacy empty pairs, raw separators and the query-pair limit. No browser-made recording or real front end yet
Stand-in sample metadata Consecutive samples compare all response fields before retained bytes are charged. Header comparison ignores name case and ordering between different names, while preserving repeated-value order and the stored headers. At capacity, a usable response replaces only an unavailable 304 for the same path, query and request key; refused bodies preserve existing evidence. All 24 combined replay regressions pass locally on the refresh onto cf414ff4. The same replay implementation and four regression files passed in frozen candidate 8758b6df on base b2d7e89e. Historical standalone revision f79dc0bd passed its 14 metadata and header/capacity regressions in full Linux CI. See this PR's checks for the current revision's complete gate.
Websites as targets web_site_open keeps a private browser for the session and deletes its temporary profile when the browser closes or fails to start; every browser tool inspects that page; web_site_capture records screenshots at each width (desktop, tablet and phone), rendered HTML, design tokens (colours in hex, spacing, content widths), the CSS breakpoints, the layout at each width (page width, heading sizes, each section's padding, gap, content column and items per row), page health (script and console errors, failed requests) and an accessibility outline, layout outline, assets with font files and requests, links and form outlines. In Clean room the capture keeps only what a visitor sees (no HTML, CSS rules, scripts, requests or errors), and opening a site reports no load errors. The Flatpak build can't start a browser on the computer (#841) Live runs on example.com and a local page with Chromium on Linux, including profile cleanup after success and failed startup; unit tests. Brave on macOS was not run
Electron window comparisons app_graphs_compare retains every unassigned window and every construction with a reused local binding. Windows are paired by module, binding and occurrence, so inserting comments does not hide preference changes. Colliding display labels receive a separate #N suffix without changing literal binding names or occurrence indices Synthetic applications parsed through the ordinary analyzer exercise anonymous and reused bindings, shifted source lines, unequal counts, literal names resembling occurrence or collision suffixes, and stable labels when only one window changes. Pairing remains positional within each binding group; reordered constructions and real application releases were not checked for this correction
Rebuild workflow (Study → Build → Check → Refine) crates/ai/src/rebuild/ (kinds, checks and stacks are pluggable: docs/extending.md). Three kinds: website, app, game (a project whose stack is a game engine is always a game). The request decides how to build: a language, framework, engine or platform it names wins over the kind's default stack (Rust + egui for apps, Unity for games, the original's for websites), and the build check, the recorded stack and Play follow what was built (an Electron app opens in its own Electron; a plain static site has nothing to build and passes the build check as it is). Websites: Study also captures up to 4 other pages of the site; menus are opened on a computer and on a phone; the check serves the build on loopback and compares every page at 1440, 768 and 390 px (likeness = mean of layout and perceptual detail, SSIM, averaged over pages, leaving out the parts of the original that change by themselves, found by photographing it three times; the note adds text, page structure, the colours, font, text sizes and spacing the build misses, and per width a page that scrolls sideways, heading sizes and sections whose padding, items per row or content column differ, the errors, failed requests and accessibility gaps the build adds, and the opened menus and pop-ups). A stack or library named in the request (Next.js, shadcn/ui, Tailwind CSS…, stacks.toml) is what the builder uses; with none named, a website's stack is the builder's choice (told to match what the original is built with) and the stack it used is recorded from app/package.json. The builder leads: it studies, asks the tools follow-up questions, records what it can't find out as unknowns (core_unknown_add; the run reports the open ones), and tests its own build mid-turn with rebuild_check (the same checks, for every kind); a check with anything it couldn't compare, or any claim that fails (a website page that scrolls sideways, logs new errors, fails to load a file, lacks a landmark, or a menu that doesn't open; for games each self-test step, for Deep-mode sheets each original number in the code, for console apps the same exit and output as the original's runs), isn't good enough; apps and games by whether they build. Up to 6 refinement rounds, or until a website reaches 90% likeness. A turn cut off by a time limit, crash or dropped connection resumes (up to 3 times); builder turns may run 24 h. A project copied from another computer (or moved to another folder) keeps building with Claude Code: the project keeps a copy of the builder's session (agent-session.jsonl) after every turn and puts it back where Claude Code finds it on a computer without it, so the same conversation carries on (#451); when the session still isn't there, a new one starts from the brief, what's in app/ and the kept requests and replies (or the last summary), and questions about the build put the kept session back too, else are answered from the files and forget the missing session (#452). A session is resumed only in the mode it was saved in (R2.9): agent_session_deep in craft.json; one saved before the mode was kept counts as Deep, so a Clean room build starts from the brief and a Clean room question is answered from the files rather than continuing a Deep session; the project keeps one session at a time, so a build that saves a new one in the other mode replaces the id and its mode. The shared investigation chat follows the same principle for its agent session: after a switch from Deep to Clean room it starts a new session instead of continuing the Deep one, while Clean room to Deep still continues. Live runs with Claude Code 2.1.316 on one Mac (2026-11-02), a second computer stood in for by a separate signed-in CLAUDE_CONFIG_DIR: a copied project's session was put back and resumed (the builder recalled its first reply from memory); a kept copy of another session was refused and the new session used the handoff; a real project synced from Windows whose session was missing started afresh and reached Ready. Not yet run between two real computers Unit tests for prompts, stack choice, site detection, feed folding; live runs reached Build and decompiling (below)
Check rounds that can't stall silently A round of the builder's own checks has a 30-minute limit; Pause is looked at before each check; and every check is said as its own step ("Checking its work (2 of 4): app-screenshot…" in the Build stage, "Checking the build (2 of 4): …" in the Check stage), so a stall names the check it is in. A check that would start past the limit is reported as not run, and a check already running is stopped at the limit by its own program runs, which watch the round's limit and the person's pause — a build step that makes no tool call is cut too. A run that ends by a caught bug records "Needs you" with why, instead of leaving the project saying "Checking" while nothing runs Unit regressions: a round past its limit, a paused round and a round with time left; a real round's check lines arrive as Check steps and a self-check round's as Build steps; a running build step is cut at the round's limit; a step that would start past the limit or while paused is refused before it starts; a caught bug leaves NeedsYou. Not checked: a live Windows build with Godot/Codex (the reporters' setup)
Context-summary usage Successful API context summaries contribute to the message totals consumed by build usage and receive a model_turn journal entry with purpose: context_summary. Input tokens include cached ones, as coding agents report them (Ollama 0.40 sends them apart). Cached-token pricing is retained; an unknown summary price makes the total unknown, and a failed call adds no invented usage Scripted-model tests exercise the real ApiConversation, transcript resumption, exact input/output and cache-price totals, journal entries, empty summaries, local zero cost, unknown prices and failed summaries. No live provider or end-to-end rebuild was used for this correction
Local model builds Regression coverage confirms that a fenced call followed by a summary or protocol marker is not run and the next model message says to retry it without trailing text (R5.4). Protocol markers between calls retain this retry condition even when later calls follow; ordinary words between calls remain supported in both ReAct modes. No live local-model build has been run after this change. Earlier, Ollama 0.40.7 with qwen2.5-coder:14b (32k context) wrote calls as JSON text, which ran whole or after a sentence; by check 3 its project compiled, but main.rs was still cargo's "Hello, world!", so the screenshot check failed at the round limit. A lean local builder's prompt asks for no memory tools it isn't offered, and a project one folder down is named in the check Historical live evidence: four CLI builds of "a scientific calculator" on Windows (RTX 5090), 2026-11-04, one fix added per run
Builders that can't see pictures A builder in the API loop (BriefCx::sees_pictures is false; agent apps open pictures with Read) is never sent to open or look at a picture. In its place: capture.json's layouts for a website's screenshots, each round's checks/round-N/capture.json beside the original's, a program's capture/ui-tree.json and the check's likeness, and asking the person with core_person_ask what their pictures show. Agent apps' prompts are unchanged apart from the --screenshot contract's last sentence (R5.4) a_builder_that_cant_see_is_never_sent_to_a_picture covers every kind, target, mode and picture case (144) and was shown to fail when a sighted phrase came back; all 150 sighted briefs and refinements were compared byte for byte before and after. No live API-loop build was run after this change
API answer time limit timeout_secs in [[ai.backends]] also bounds an API backend's streamed answer, waiting for it to start included (five minutes to start and one hour in all when unset or 0), so a slow local model can take longer for a long answer (#1096). A stream that runs out of time says to set it Unit tests for the limit taken from the setting and for the remediation on a body timeout; no live slow model was run, and a request queued on a shared server (#1239) was not run live
AI connection errors An API backend that took the request and didn't start answering says so, instead of "Couldn't reach". For an address on this computer (localhost, 127.x.x.x, ::1), the advice says a large model may still be loading or reading a long prompt and that a smaller context length helps, and a failed connection says to check that the server is running on this computer, without the internet advice remote services get Unit tests for both kinds of failure on local and remote addresses, and for what counts as this computer. Seen live with a local Ollama whose 131,072-token model took over five minutes to start answering (before the change); the new messages were not run live
Backend context budgets context_tokens in [[ai.backends]] controls when an API conversation is trimmed and summarised. Zero or omission retains local/cloud defaults; a nonzero conversation override takes priority. Before each attempt, including a fallback, fitting adds estimated history growth since the last successful request to its reported input size. Trimming resets that reference, and successful requests refresh it; summary usage remains in message totals. When a server refuses a request for its context window and says the size (Ollama and llama.cpp's "exceeds the available context size", OpenAI-style "maximum context length is"), the error carries it (context_window, prompt_tokens), the conversation is fitted to three quarters of it (it replaces the local/cloud guess; a set budget stays the most) measured with the server's own count, and the request is sent once more, by each backend in the chain and only when room was made (without the server's count, the refused request is taken as one token over the window); if that fails too, the remediation says how to raise the window (#962) Regressions cover settings and model construction, defaults/overrides, smaller fallback budgets, large-budget arithmetic and new tool output growing beyond a fallback budget even when the history estimate alone is below the reported input. The latest tool results are preserved, and a short follow-up does not count already-sent history twice. a_request_too_long_for_the_servers_window_is_fitted_and_asked_once_more covers a refit that then fits and one that doesn't (asked once more, never again); a_refit_makes_room_first_and_each_backend_gets_its_own covers a refusal without a count, one with nothing to trim, and a fallback refused for its own window; the window is read from the whole message, and OpenAI's prompt part "in the messages", not its total; the server's two wordings are parsed in http. This does not set server context parameters, and LM Studio's refusal names no size, so it isn't refitted; no live provider was used
Games Engine detection for 12 engines (Unreal, Unity, Godot, Source, GameMaker, RPG Maker, Ren'Py, MonoGame, LÖVE, CryEngine, Cocos, Cube) with versions. Unreal and Godot games are rebuilt in the same engine, others in Unity; installed engines are found, Godot installs itself, others get guided installs. Picking an inner folder (Engine, Binaries, Paks…) finds the game's folder. Just look inside a game shows what it's made of (core_target_triage on its folder: engine and version, how its code ships, the libraries its Unity assembly names give away, its own code, scenes and size) and opens it in the chat to ask about it. The builder keeps app/MECHANICS.md and its structured twin app/mechanics.json (checked after each build), in Deep mode only, may reuse the original's readable files for private use (never decrypting; generated pictures and 3D models replace its art when the person turns them on; Clean room copies none of its files), lists them in CREDITS.md (checked, with the private-use line in README.md); a game is ready only when its --self-test shows the player moving, acting and the HUD drawn, and the result can be started from the project page Unit tests; live runs on Windows
Clean room and Deep mode Clean room (the default) runs only the tools in engine/src/clean_room.rs: ones that touch no target or watch from outside (the website as a visitor sees it, pictures of a window, its controls, recorded runs, a phone's screen). Every other tool, a plugin's included, is refused in the app, CLI, MCP and agents, with a way to turn on Deep mode. A Clean room build studies an app or a game only from the person's pictures and words (and a picture of its window when runtime study is on); its builder's reads and commands go through an approval rule that keeps it out of the original's folder and site (with Claude Code, and with ACP agents for what they ask about; other agents aren't held to it, see roadmap R2.2). A builder over SSH starts the remote host's own craft-anything-cli mcp with this run's --deep or --clean-room, so the remote settings don't decide the mode; every release since 0.1.0 knows those flags and --all-tools, the only ones it is given (a test on mcp_for keeps it so; Codex's adapter adds only --all-tools). Claude Code, Codex and OpenCode builds over SSH first check that the host has craft-anything-cli. No release up to 0.5.0 reads CRAFT_ANYTHING_AGENT, so there a CLI the remote builder starts calls tools as the person (R2.8). Deep mode (deep_mode in Settings, --deep for one CLI run) uses every tool: the builder sees them all, and a website's study also reads its JavaScript and watches its start page for ten seconds (capture/how-it-works.md). Ghidra adds its decompiler in Deep mode when it's installed: it is found, or installed after asking. Study starts one analysis of the main program, saved and shared with the builder's tool server through a lock file (up to 8 h, Java gets half the machine's memory or the amount set in Settings → Engines, 4 to 31 GB, four slow passes skipped). The builder must decompile before the build is checked; addresses the built-in analysis can't place go to Ghidra, which makes a function on demand (for this run only) where its analysis has none, e.g. code reached only through tables of pointers. Without Ghidra, Deep mode uses the built-in engines Live runs with Ghidra 12.1.4 on Windows (a shared analysis, and a decompile in seconds on a large program). Live runs with Ghidra 12.2 on Linux x86-64 (decompiles by name in position-independent programs and shared libraries, whose addresses Ghidra moves). The guided install of Ghidra and its Java is offered on Linux and macOS too, but has only been tried on Windows. Clean room and Deep mode: engine, AI, MCP, CLI and app tests; no live Clean room build run yet
Auto mode Settings → Safety, on by default. Builder actions go ahead without asking, except a fixed set that is never done unasked (deleting outside the project, system changes, publishing…); questions get "decide yourself"; asset spending stops at the budget. Each project can choose allow, ask or refuse per kind of action instead (project_approvals_set, the Approvals menu under the prompt box, or /approvals publish ask; read-only gh … view/list count as commands, not publishing) Unit tests, UI tests; not tried in a live build
Generated assets Off until the person turns them on for a game (the switch on Make and on the project, project_assets_allow, rebuild --generate-assets, saved in craft.json; turning it on without a fal.ai key asks for one); the brief and the asset tools need both that and a key. assets_image_generate (Nano Banana Pro by default) and assets_model_generate (picture → Tripo P1 low-poly GLB with a face limit) through the person's key for each asset provider (fal.ai today), with agent apps and API-key builds alike; per-project budget, $5 by default ([assets] budget_usd in config.toml); models and prices from the assets.toml table (picture model selectable: Nano Banana Pro, FLUX dev or schnell; priced per picture or per megapixel); every call reports its cost Unit tests; a live 3D generation with a real key (picture, then model) with FLUX dev; Nano Banana Pro not yet run with a real key; an API-key build not yet run with one
Claude Code builder Runs the person's own claude in headless mode (Opus 5.5, high effort unless configured) with our MCP server, a permission-prompt tool and core_person_ask; preflights for our CLI (a build stops plainly if it's missing or won't start) and sign-in Argument and stream-parser tests; live preflight; live builder turns; see claude-code.md
DeepSeek Harness builder Runs the person's own dsh --profile headless with the preamble and task on stdin, which answers one task and prints its last message as text. The harness takes its tool servers from profile patch layers and has no per-run flag for one, so our tool server arrives as a generated --patch overlay for that run (the run's project, inbox and mode included), under a server name of its own so it doesn't clash with a craft-anything entry the person registered; the person's own profile is untouched, a question gets no tool server, and its headless profile keeps no session to resume. Standard npm shims are unwrapped to their interpreter; the desktop app's custom .cmd launcher receives only options, avoiding batch newline and command-line length limits. Requires a headless profile with stdin support (0.2.2-rc.1 verified); older versions without it reject the missing task and need updating Adapter and YAML-overlay tests; live preflight (ai test); live builder turns on a website (follow-up build, 3 min 10 s, 100% alike at 1440/768/390 px, Ready) where the builder's own journal entries show rebuild_check, core_unknown_add, core_plan_update and core_handoff_write going through our tool server, and that server started with the run's --project/--inbox. Not checked: resume (none exists) and a build with the harness's desktop profile. Also verified on macOS arm64 (2026-11-07, DSH 0.2.2-rc.1, stored sign-in restored for the headless profile as its README describes): a static website reached Ready with one check pass, and the builder called our MCP tools after renaming a pre-existing craft-anything MCP registration to avoid the generated overlay's matching serverName; Windows (2026-11-07): the new batch-launch regression failed with the reported startup error before the fix and then passed, including exact UTF-8 and 40,831-character task delivery. A patched Craft CLI chat through the official desktop dsh.cmd returned the expected answer with a local authentication overlay; no new GUI or full rebuild run was performed
Aider builder Runs the person's own aider --message "<task>", one message per run. Flags stop it asking or acting on its own: no git repository or .gitignore change, no update check or release notes, no analytics, Playwright, URL or shell-suggestion prompt, no model-warning page, and plain output. BROWSER points at a command that does nothing, so no page can open from a run. Before a run it refuses when no model or key is set up, or an OpenRouter model has no OpenRouter key: both would offer a sign-in and wait five minutes for a browser nobody is at (#72). That check reads Aider's settings (.aider.conf.yml, .env) where Aider does: in the folder the run starts in (links resolved), at the top of its git repository (a .git file, or a .git folder with HEAD, as GitPython finds it) and in the home folder, plus an --env-file from its arguments; the one Aider loads last wins, and a .env wins over the environment, as Aider loads it over the environment. An empty KEY= in a later file doesn't clear a key set in an earlier one, and --config isn't read. A run over SSH checks only this computer's home folder, as before. Outside a build --dry-run keeps a chat from writing files. Aider gets no tool server, and its own reads can't be checked, so a Clean room run is refused (R2.2). A failed flag check keeps this adapter: Aider's plain form reads the message as a file name Argument, registration and setup-refusal tests, including settings in the project folder, the git repository's top and which file wins (from Aider's main.py; not run against a real Aider). Ran Aider 0.86.2 with these exact arguments: no prompt, no browser, reached the model call; the no-model and OpenRouter cases were reproduced (each waited for the sign-in) and are now refused before the run, and also at a real build start with the key unset. Live build (2026-11-07, Linux, Aider 0.86.2 through rebuild --backend Aider --unattended, one round, free nvidia/nemotron-3-ultra-550b-a55b:free through OpenRouter): a static site reached Ready in about 66 s with four files written in app/, no question waited and no browser opened; the file-creation questions took their default on closed stdin. The page only shows an alert where the request asked for a colour change, so the output was not judged. An earlier try with cohere/north-mini-code:free looped, wrote nothing and stopped after two turns, and Aider offered to open a help page that opened nothing. Aider reports no token counts, so usage shows 0. Not checked: a stronger or paid model, resume, Windows, macOS
GitHub Copilot Installed copilot through ACP by default, with CLI-owned login (no credential import), explicit Craft Anything MCP tool allowlist, model selection and fresh read-only build questions. Target handoff retains the last 128 entries with the active target last; context discovery respects tool cancellation and shared picker warnings name the agent Authenticated builds, model discovery and real-account session resume confirmed by the person using the app. Target-boundary, cancellation and agent-warning regressions supplement unit tests and an offline CLI 1.0.105 compatibility test covering all five access modes. See copilot.md
Grok Build Installed grok through ACP by default (grok agent --no-leader stdio). Sign-in stays in grok login. An existing auth.json counts as signed in and is not read; a missing file is unknown, so the run itself reports an authentication problem. XAI_API_KEY is separate: detection reads it and the xAI API backend can use it; this adapter does not. Clean room, deep chat, and questions are refused, because Grok can read and edit without a permission request and grok agent has no flag that holds those modes. A deep build is allowed. The chosen model is applied with session/set_config_option after session/new, because the CLI --model flag does not survive that call. Reasoning effort is passed after agent and set again after the model. Our MCP server is attached on the session, and only this agent is sent "type": "stdio". The person's own Grok MCP servers are not removed. Thinking uses the shared model picker; there is no context-window control. acp = false and SSH are refused Scripted ACP tests for the argument order, "type": "stdio" on Grok's server only, and session/set_config_option before the prompt, including a value the session already has. initialize, session/new and session/set_config_option were checked against Grok 1.0.77. A live deep build on 2026-11-06 (Grok 1.0.77, temporary ask-mode home) finished, called the Craft Anything server, and answered one permission request. The person's own config was not changed. See grok.md
Shared investigation for local agents A worker saves session-only investigations before starting MCP, shares open targets in a mode-aware handoff, and reloads externally recorded evidence/findings. Builder refresh failures warn rather than ending the turn. The workbench Evidence pane shows fnd_* records with proof links; core_finding_edit preserves ids and omitted confidence while checking evidence and stale revisions Engine persistence/correction tests, process-level MCP target tests in both modes, and headless findings-rendering test; live authenticated target-to-finding workflow confirmed by the person using the app
Copilot model options Shared agent catalogue, model/thinking picker, cli_model/cli_thinking and ai_models_list/ai_model_set; selected-model reasoning metadata reloads without a prompt. Context tiers remain separate through ai_model_options_show/ai_model_options_set, preserving thinking. Legacy reasoning settings remain readable Isolated catalogue/validation, flags, persistence, stale-result and headless UI tests. Previous authenticated metadata checks used CLI 1.0.105; no new live-account run after the shared-picker rework. Numeric context limits are not advertised in its initial ACP metadata
Investigation writer coordination Every project-backed mutation holds one OS file lock over load, revision validation, mutation and state/Markdown writes. Waits are bounded and cancellable; unreadable state is not overwritten Separate-process append/revision-race tests, matching Markdown renders, lock timeout/cancellation/release and malformed-state regressions
Agents over ACP Opt-in per backend (acp = true): Gemini CLI, Qwen Code, opencode, goose, Hermes, Maki and Devin in their ACP mode, one agent process per chat or build with our MCP server; Maki's and Devin's ACP modes take the backend's model (cli_model). An agent in ACP_KEY_AGENTS (Devin today) gets the backend's stored key when its authMethods ask the host to authenticate (authenticate with meta.api_key; Devin needs this — its own CLI sign-in doesn't count over ACP). A builder whose saved session the agent can't take back fails the turn marked lost, and the run starts the new session from the brief. In chat, permission requests become consent questions; in builds they go through the same approval policy as Claude Code's (inbox, Auto mode). While a saved session loads, replayed updates are withheld from the new turn Protocol unit tests against scripted agent messages and an approval-policy test. Run live with Maki 0.7.0 only (2026-11-02, Linux, headless CLI): a static page built to Ready in 38 s, a follow-up continued the same session with session/load, and with Auto mode off its command and tool requests were refused in an unattended run. Replay suppression passes scripted load-history, success/error and cancellation tests; this correction has not been rerun with a live agent. Run live with Devin 3000.11.238 (2026-11-03, Windows, headless CLI): devin acp authenticated with the backend's stored key, answered a chat, and built a Rust app to Ready through a rebuild run. Turns report 0 tokens over ACP
WASM plugins With --features wasm-plugins: [[plugins.wasm]] components exporting craft-anything:plugin/tools add tools, and ones exporting craft-anything:plugin/checks add checks run after each kind's own (they get the build's file list as JSON) (added, listed, turned on or off and removed in Settings → Plugins or with plugins_add/plugins_remove/plugins_list); no imports, fresh instance per call, fuel and memory limits Tests with components written in WAT (describe, call, checks, a looping call stopped, imports refused, end to end through the engine); examples/wasm-plugin-wordcount built from Rust and loaded
WebAssembly tag interfaces formats_wasm_compare resolves retained imported and defined tag exports to their declared parameter types. Identical unresolved or invalid diagnostics may still count as unchanged; those counts do not establish interface compatibility, and invalid/partial limitations remain present Synthetic core modules with tag changes and re-exports, mixed index spaces, import/tag limits, and missing or non-function type references; formats and engine tests. No real module corpus or WebAssembly execution was used for this correction
Questions and approvals A file inbox per project; core_person_ask, core_action_approve and MCP consent requests become cards in the app Cross-handle round-trip tests, a full approval round trip through the engine
Runtime assets in pinned builds Frozen and light pins, size estimates and project copies keep runtime files in obj folders. An obj directory beside a regular C#, F# or Visual Basic project file is still recognised as compiler output; ambiguous folders are retained. New pins record the direct-launch program relative to the copy so a newer helper cannot replace it; older pins retain discovery behavior Synthetic filesystem tests cover both pin modes, model bytes, compiler-output controls and project duplication. A Linux tool-level regression starts temporary scripts through project_pin_open, with a newer Build/obj/helper, and verifies the originally selected program and its output; a missing recorded program is refused. No real pinned application was launched for this correction
Desktop app Simple mode: sidebar with New project and the project history (kept across restarts); New project makes something, works on a project the person already has (Work on my project: its folder's files are the app, edited in place without a question, and the project takes the folder's name), or just looks inside an app or file, a website or a game's files; a Game files screen (a game's archives; pictures from Unreal paks, Unity .assets files and Unity bundles saved as PNG after the person confirms they may unpack the game; uncompressed textures and the block formats DXT1, DXT5 and BC4–BC7), make prompt with picture attachments (picked, dropped, or pasted with Ctrl+V, shown as picture tiles) and, for anything recreated, a Clean room / Deep choice (also in the title bar; in Clean room, Just look inside, Game files, opening a file and the workbench ask for Deep mode instead), project screen (steps with the time spent and the AI cost and tokens of every build, saved in the project's usage.json by the run (a coding agent's figure is shown as an estimate at API prices, not the bill), what the build is on now and its activity as it arrives (kept in build-activity.log), pinned builder checklist (its X folds it away between builds, kept in the project, project_plan_fold; a later run's checklist shows again; its steps scroll past a height set by dragging the divider above it, or with Up and Down, kept across restarts, #826), feed (each message and answer has a copy button, shown on hover or keyboard focus, #825), question and approval cards, a Continue card when a build was paused or stopped part-way (the app or computer closed; the project shows Interrupted) that carries on the builder's own session instead of starting over, and "It's done" beside Continue or Try again to keep the build as it is (project_build_finish), checks with screenshots and the requirements not met yet, the builder's open questions, preview, play, folder, follow-ups while it builds, which Claude Code takes at its next step; Up in the prompt box takes back the last note still waiting). Projects can start in a folder the person picks, whose files are either the app, edited in place (its stack read from those files unless the request names another, and, with nothing to recreate, judged by its own build and tests, whatever it's written in), or material to start from (asked, or the answer remembered in Settings), and are listed from any number of folders (project_folders, project_list, rebuild --project-folder). Make says which AI builds ("Built by": automatic, or any AI that can build, by name); a pick stays with the project and builds its later changes. With nothing to build with, Start offers the coding agents found on the computer. Settings → AI turns an AI off or removes it, and sets how hard the Claude API or Claude Code thinks (every Claude level, low to max; also ai effort in the CLI). Each Claude Code AI can keep its sign-in in a folder of its own (its CLAUDE_CONFIG_DIR, so its own account; ai folder in the CLI, a folder on that computer over SSH), used for its runs, its sign-in check and its kept session, and Add another adds a second Claude Code for a second account. In the prompt box, Up at the very start and Down at the very end go through earlier prompts when no note is waiting. Questions about a build ("Just ask" under the prompt box, or a message starting with /btw, the first slash command; rebuild_question_ask) are answered in the conversation, where each folds away and is kept in the project, without a build or a round and changing nothing (the next message or a note tells the builder the latest few as background, a Clean room build only those asked in Clean room): Claude Code answers from a read-only copy of the builder's own session. Under each project's prompt box, "Builder's questions: Ask me / Decide yourself" chooses whether the builder's questions come to the person as cards or are decided by the builder, which says what it chose (project_questions_set; the default is in Settings and follows Auto mode until picked). Projects can be renamed, duplicated and deleted (right-click in the sidebar, or the project's page; a delete keeps the person's own files). A build can be pinned (Pin this build on its page, or project_pin_* from the CLI and MCP): a frozen copy in the project's pinned/ folder (the default) or a light one that shares dependencies and media with the project through hard links (each one's size shown first), opened from the sidebar's collapsible Pinned section (icons with a running dot when folded); a pin or Play runs once per folder unless another copy is asked for, and a start that quits at once says so with its last output. Typed drafts survive a restart. In a narrow window the sidebar folds to icons and the project's details move above its feed; messages float over the screen and errors stay until dismissed. Advanced mode: workbench with every panel wired to real tools, as a screen beside the projects (builds and their questions stay a click away). On macOS the menu bar has the app's actions (open, new project, settings, Simple / Advanced, Clean room / Deep, the command palette, help) with the usual shortcuts UI unit and smoke tests (egui_kittest), offscreen snapshots of every screen
CLI Every tool, --deep or --clean-room for one run (never saved), rebuild (including --continue-in, and --resume to carry on a stopped build), mcp (--inbox, --restricted, --allow-web, --allow-capture), ai, setup, doctor, report CLI integration tests
SQLite database files (db_sqlite_show) A rowid alias column (INTEGER PRIMARY KEY, including the table-constraint form) shows the rowid; DESC, non-INTEGER and composite keys keep their stored values; a VIRTUAL generated column, which SQLite computes when a row is read and never stores, shows as not read, and the columns after it keep their own values; a whole number in a REAL, FLOAT or DOUBLE column, which SQLite stores as an integer, reads as a REAL, as SQLite returns it Hand-built fixtures; generated files compared with the official SQLite library
SQLite WITHOUT ROWID tables Read from the index b-tree, interior records and overflow included; rows in primary-key order, values in declaration order, rowid null; WITHOUT ROWID and STRICT are found after the column list's own closing parenthesis, so a ) in a trailing comment doesn't hide them Hand-built fixtures; generated files compared with the official SQLite library
SQLite CREATE TABLE longer than 4 KiB Parsed whole (up to 1 MiB), so its later columns, rowid alias, WITHOUT ROWID and added columns' defaults hold; the statement shown is still cut at 4 KiB Hand-built fixtures; generated files compared with the official SQLite library
Builder discovery smoke fixture The missing-builder smoke fixture controls discovery state and supplies a synthetic result. All original warning, modal, action and build-availability assertions are retained. Source inspection only; automated validation has not yet run for this change.
Parser review follow-ups Java reference scans retain partial coverage; DEX signed LEB128 enforces 32-bit values; legacy AAPT strings stay inside their pool with a shared recovery probe limit; missing classic ext indirect metadata is not recovered as zeros. Shared-budget revision 29c48e03 passed full Linux CI. The merge with main 41d2175e awaits a new CI run. Extent-tree metadata handling is unchanged.
Stand-in retained body budgets Check per-body limits after redaction and charge the capture budget only for distinct retained samples. Budget-rejected cached 304 responses remain unavailable. All four original capture regressions and six deduplication regressions passed in full Linux CI at revision d601bc4e. Workspace tests, strict Clippy, formatting, layers, locks, secrets, wasm-plugin checks, shared WASM compilation and the lockfile check passed.

| Plan steps stopped at a run's end | A run that finishes (ready, failed or paused) marks still-open steps Stopped on the plan card instead of leaving them "Doing" until the card is folded (#504). The stopped steps stay in the saved conversation (FEED_VERSION 5); a later run's checklist updates the list again, and a plan left partly unticked still shows with its stopped steps | Regression tests in ai::rebuild::feed (ready, paused and no-checklist finishes, a later run taking the list over) and an engine save/load round trip of a stopped step; the checklist draws a warning circle for stopped steps. Not checked: a live desktop run |

Builder retry policy

Builder failures carry a typed reason through Conversation::last_failure. Typed authentication, billing, missing programs, unavailable tools, configuration and unknown protocol failures stop for attention. Transport interruptions, rate limits and nonzero process exits without a typed error get at most three retries; the decision no longer searches English error messages. Structured provider waits win; the earlier numeric “retry in” hint is only a delay fallback after a failure has already been classified as retryable. All waits remain cancellable and bounded to fifteen minutes. Local inbox and workspace write failures are not retried using a concurrent backend failure's retry advice; the original local error is returned. A missing saved session starts afresh only when a fresh request is available; otherwise the run stops without retrying the unavailable session.

Claude Code's failed or unauthenticated craft-anything MCP server in its init event stops the owned CLI process. Pending servers and failures in unrelated optional servers do not stop it. Claude assistant error codes, HTTP status/provider errors and ACP authentication errors retain their typed meanings. A later generic result does not erase a more specific error.

API retries continue the existing history without inserting the user's message again or replaying completed tools. Stateless CLI retries receive the whole original request. OpenCode now uses run --format json: its API error status and retry flag decide retryability while text, tools and usage still reach the feed. Missing or invalid step costs keep the turn's cost unknown; explicit zero remains a known cost. A CLI that fails with only a numeric exit also uses bounded retries; its display error remains available if recovery fails. The process wrapper sends one final turn event and becomes available for the next request.

Protocol fixtures, a loopback HTTP server, scripted API turns and executable CLI stand-ins cover these paths, including cancellation and the retry cap. An executable that exits 1 without a structured error resumes its saved session, while typed setup errors retain priority over the same exit status. No live provider or paid-model run was performed. The separate source of #64's 41 attempts remains unverified.

Bun stored-text encoding

Packed Bun members with encoding value 2 are labelled utf16le, matching their stored UTF-16LE bytes. Reading or unpacking preserves those bytes. Synthetic graphs cover UTF-16LE (including a surrogate pair), Latin1 and binary members across both supported module-record and offsets-block sizes. A freshly compiled Bun program and the CLI/MCP transport were not run for this correction.

Native tool-call stop reasons

Native OpenAI-compatible tool calls retain a reported output limit or refusal instead of replacing it with a tool-use stop. The conversation can therefore reject those calls before running a tool, including calls whose arguments happen to be valid JSON. A normal stop with tool calls still works for servers that omit tool_calls as the finish reason. Calls retained after a pause or another terminal stop get matching non-execution results, so subsequent requests keep valid tool-call history. A pause continues the same turn; terminal stops wait for the next user message. Checked with streamed-call fixtures and HTTP/SSE stand-ins through the real conversation and engine loop. Three history-pairing regressions fail without the follow-up and pass with it. The affected crate's 223 tests and Clippy checks passed locally. The initial stop-reason correction also passed hosted CI in PR #544. This correction concerns reported finish reasons; handling of a missing finish reason is unchanged. No live provider or local-model build was run.

OpenCode review follow-up

OpenCode variants now use the shared five-level Effort type while retaining exact catalogue validation. Hub and headless tool selections share a strict disk-based save that preserves unrelated settings changes and refuses damaged files or changed backends. Regression tests cover both entry points. Rejected or cancelled model validation emits a terminal turn event so headless chat exits.

Unreal setup

Unreal installations registered in ~/.config/Epic/UnrealEngine/Install.ini are found on Linux. A valid absolute UE_ROOT selects an installation explicitly; an invalid override falls back to registered installations. The version comes from Engine/Build/Build.version, and C++ readiness checks for the selected engine's bundled Clang, not an unrelated system compiler or another installation's SDK. The Linux requirements summary (Builder::needs for Unreal) now describes the bundled Clang toolchain. The guided installer now gives Linux-specific guidance: it names the bundled Clang and points at the engine's Engine/Build/BatchFiles/Linux/SetupToolchain.sh (or Setup.sh for a source build) when Clang is missing. On macOS, the status line and requirements summary now name Xcode, matching the guided step. The guidance strings are unit-tested; no live Unreal install or macOS run was performed for this copy change.

Checked with isolated registry and SDK fixtures and with a native Fedora install of Unreal 5.8.4. On Windows, Visual Studio C++ readiness also checks instances registered in %ProgramData%\Microsoft\VisualStudio\Packages\_Instances\*\state.json and explicit developer environment roots (VSINSTALLDIR, VCINSTALLDIR, VCToolsInstallDir), requiring cl.exe under an MSVC toolset's bin tree rather than an empty VC/Tools/MSVC or version folder; checked with isolated fixtures and on Windows 11 against Visual Studio Community 2026 (18.9.2, MSVC 14.51.36231). Readiness is a tool-presence check; a complete Unreal game build and SDK compatibility validation have not been run for this change.

Provider error messages

HTTP failures include the provider's message from error.metadata.raw, when it contains a message, detail or string error. Object payloads, JSON-encoded strings and plain-text reasons are supported, with the provider's name when supplied. A repeated outer message does not hide a distinct nested detail. JSON-string wrappers are decoded to a bounded depth before reading message fields; arbitrary, malformed or excessively wrapped structured metadata is not dumped. HTTP status classification and remediation are retained, and displayed details are bounded by Unicode characters. Checked with synthetic response bodies, repeated messages, encoded payloads with adjacent headers, malformed metadata and Unicode length controls. The affected crate's 222 tests and all-target Clippy checks passed locally for PR #542. No live API-key build or account-specific diagnosis was performed.

Fixed during the audit

Web tools couldn't launch a browser on Windows/macOS (Chrome/Edge are off PATH) or be pointed at a URL; the desktop app looked tools up by ids that didn't exist (website, phone, imports, classes, modules, pseudo-C, disassembly, source and network panels were dead); evidence wasn't reloaded from a project in a new process; report citations were unresolved; the CLI's --format clashed with tools' own format; raw binaries couldn't be opened from the CLI; function discovery claimed complete coverage when capped; .NET/Go binaries were called "stripped"; Windows path separators and CRLF checkouts broke two tests; decompiler tail calls and Win64 stack arguments. Added since: byte search, Rust binaries, Electron fuses, WASM interface diff, packet captures, objdump, rizin commands, GDB sessions, then rizin debug sessions (native_rizin_session_*, checked with Rizin 0.9.1 on Windows) and radio decoding with rtl_433 (radio_recording_decode, radio_decoders_list, checked with rtl_433 25.12 on Windows) and Cutter sessions the person shares with =h& 9090 (native_cutter_sessions_list, native_cutter_command_run; tested against a stand-in server, not yet a real Cutter). Every tool is listed in docs/tools.md.

SquashFS extended directories

The filesystem reader recovers the same files and bytes from basic and extended directory inodes. Synthetic images cover an extended root, a nested extended directory with a nonzero listing offset, and both together; the results are compared with the existing basic-directory fixture. Compressed metadata, directory indexes and a real firmware extraction were not newly checked for this fix.

Keep-awake helper cleanup

Rebuilds release their keep-awake guard before emitting Finished and clearing the running flag. The guard waits up to five seconds for the owned helper's supervised cleanup, logging a warning if that deadline passes. Cleanup runs on the rebuild worker, with a bounded shutdown wait.

Checked on Linux with real subprocess stand-ins: dropping a guard closes the helper's listener, a stand-in CLI can drop it and exit immediately without leaving the helper running, and an already-finished helper releases promptly. The immediate-exit case fails with the earlier asynchronous cleanup. The intermittent Windows report and Windows/macOS sleep inhibition have not been rechecked for this change; Windows runtime validation remains on the roadmap.

The full workspace gates (cargo xtask ci) passed in hosted CI for #541.

Tool calls written as JSON

The text fallback accepts complete bare or fenced JSON calls with name and arguments (parameters also accepted), including a function wrapper and JSON-encoded arguments. Automatic recovery also handles these responses when native tool calling was offered. A call must name a tool offered in that turn; ordinary JSON answers and JSON examples surrounded by prose are left as text. Native calls are kept once; text-call recovery skips truncated or refused replies. Complete backtick-fenced legacy ReAct steps remain supported when their body begins with an explicit protocol marker. Both parsers use the same fence boundaries: at least three opening backticks and a standalone closing line of at least that length, with no earlier matching closing fence. Shorter backtick lines inside a longer fence remain content. Ordinary fenced code, malformed fences and non-call JSON objects or examples containing protocol markers remain text; valid call arguments may contain those markers. The parser regressions failed on the previous guards and passed with their corrections. Fenced JSON calls also use these boundaries during automatic recovery and accept only an empty or json info string. Checked with parser fixtures, HTTP/SSE stand-ins exercising real engine tool execution in both protocols, and non-action, stop-reason and duplicate-call controls. No live local-model build was run; other text-call formats remain unsupported.

Calls in Qwen's markup (<tool_call>, <function=name>, <parameter=key> value </parameter>) are read too: a llama.cpp server hands one back as text when it names a tool the model wasn't offered, and a live build on a 512k-window Qwen model stopped in 3 minutes when the loop took web_search and web_fetch calls for its final answer. Words may come before the first call; the last </tool_call> may be missing. When every name is offered the calls run, a parameter the schema says is a string staying as written and any other read as JSON when it parses. When any isn't, nothing runs and the next message names the wrong ones and the tools the model has; words after the last call ask for it again without them, as with fenced calls. A call in a code fence or in the middle of a line, or one missing </parameter>, stays text. Checked with the live runs' texts, an HTTP/SSE stand-in where the model calls a missing tool, is told, runs a real one and answers, and two mutations (the reader off, names not de-duplicated) that the tests caught. Not yet run live after the change. Hermes-style <tool_call>{json}</tool_call> is still text.

Linux graphics card choice

On Linux the desktop app draws on the GPU that drives the screen (#571), read from the connected displays in /sys/class/drm: the built-in panel's GPU on a laptop, the only GPU with monitors on a desktop, and the discrete GPU when monitors are on more than one GPU or nothing can be read. WGPU_ADAPTER_NAME and WGPU_POWER_PREF still decide when set. desktop.log says which adapter was chosen and why.

Checked live on one laptop (AMD Renoir iGPU driving the panel, NVIDIA RTX 3050, CachyOS, KDE Plasma on Wayland): the window opens in 3 s on the AMD GPU instead of 18–25 s on NVIDIA, and the desktop no longer lags; WGPU_POWER_PREF=high, WGPU_ADAPTER_NAME=nvidia and DRI_PRIME=1 with WGPU_POWER_PREF=none still draw on NVIDIA. Desktops with monitors on one or two GPUs and Intel laptops are covered by unit tests on fake /sys/class/drm folders only.

Windows renderer fallback

On Windows the window draws with DX12 on the graphics card. A start that never opens its window (a driver that crashes the process, or a wgpu error such as DX12 refusing egui's pipeline, #794) makes the next start take the next renderer: WARP, then Vulkan, then OpenGL, then DX12 again. After a wgpu error the app starts again by itself with the next one; after a native crash the person starts it. The renderer that opened the window is kept in renderer beside desktop.log for this app version, so an update tries DX12 first again. WGPU_BACKEND and CRAFT_ANYTHING_RENDERER still decide when set.

Checked live on an RX 6900 XT (Windows 11): a build that turned every DX12 start into #794's wgpu error went DX12 → WARP → Vulkan by itself in about 2 s, opened on Vulkan, kept it at the next start, and went back to DX12 for another app version. The real #794 failure wasn't reproduced: DX12 and WARP both draw on that machine.

Headless project and engine tools

Rebuild runs save the project's conversation in the versioned feed.json, including runs from the CLI. project_show reads it with offset/limit paging, and project_inbox_answer answers waiting questions and approvals. These tools are available through the engine, CLI and MCP.

engines_list reports external and game-engine readiness; engines_install installs Ghidra, Godot and pinned engines. Unity and Unreal still need their vendor's installer and account: the tool opens an installer where supported, or reports the download page and requirements. project_play launches a built app or game with consent, project_preview serves a built website on loopback, and project_open_folder opens its folder. A preview lasts for the session; use wait to keep a CLI preview serving until cancellation. The desktop app calls these tools too.

Checked against the registered tool implementations and rebuild feed writer; no live install, launch or preview was run for this documentation correction.

Known limits

  • Locks: every mutex but the browser viewer's goes through platform::sync. A deadlock on one thread or across threads is broken when it forms, with an error and a report in logs/; a watchdog looks every 5 s; a holder that isn't a labelled job is reported after 2 minutes and waited on for 15 at most. Tools are labelled, so they may run as long as they need. Checked by unit tests of each case, not by a live deadlock in the desktop app. Waits on channels and join aren't watched; each child program has its own deadlines.
  • A failed agent CLI run says what ran and what it printed, and writes a private log to logs/ in the config folder (the newest 50 are kept; the person's message is left out; Open log in the app, log: in the CLI). Checked live against a GitHub ssh alias from the CLI; the button by a UI test, not by clicking it in the desktop app. API backends and MCP start-up don't write these logs yet.
  • Live end-to-end runs (2026-10-18, Windows 10, headless CLI): a website clone reached Ready at 96% likeness in 1.5 min; a small desktop app rebuilt in Rust + egui reached Ready in 9 min (checked only by building); a game rebuild in Rust reached Build and was stopped before Check. The website case is an opt-in test: CRAFT_E2E=1 cargo test -p craft-anything-cli --test live_rebuild.
  • Approvals differ by agent (roadmap R2.2): Claude Code asks our approval tool; OpenCode's builder runs with --auto; Hermes's -z turns its approvals off on every run, chats included, so a Hermes chat isn't limited to analysing and Clean room's approval rule doesn't reach it. Hermes is opt-in and hasn't been run live here.
  • Grok Build (grok agent stdio) is offered when grok is installed and speaks ACP by default. Model and reasoning effort are set again with session/set_config_option after session/new, because the CLI --model flag does not stick; --reasoning-effort is also passed after agent. Our MCP server is added on the session. "type": "stdio" is sent only for Grok. The person's own Grok MCP servers stay available. Clean room, deep chat, and questions are refused: a native read does not ask permission, and a saved permission can edit without a request. A deep build is allowed, and an edit is gated only when Grok sends session/request_permission. A missing auth.json is unknown, so an API key is not blocked. Checked against Grok 1.0.77: initialize, session/new and session/set_config_option. A live deep build on 2026-11-06 finished, called the Craft Anything server, and answered one permission request under a temporary ask-mode home. The person's own config was not changed. A config that approves every tool does not ask. See grok.md.
  • Maki (maki -p, or over ACP with acp = true) is offered when adding a coding agent and found by Detect. Over ACP it asks us before commands, our own tools and writes outside its working folder; writes inside that folder (a build's project folder, our own records included) and every read never ask, so the approval policy and Clean room's read rule don't reach those. Plain maki -p doesn't ask at all, so a Clean room build's reads aren't checked either; outside a build it runs with its writing tools, shell and code execution switched off, and Maki refuses anything else that would ask (an MCP server's tools, in subagents too) unless the person allowed it in Maki's own permissions. It hasn't been run as a maki -p builder here.
  • Claude Code is fully wired as a builder; Codex works through its own flags (our tools are pre-approved for codex exec and every tool permitted by the current mode is listed from startup, see docs/codex.md) but doesn't resume. Codex 0.166.0 received the full Clean room inventory through a loopback model; no real-account build has been run; Copilot builds, model discovery and real-account session resume were confirmed by the person using the app. Other agent programs without an adapter get plain text in and out. API-key backends (Anthropic, OpenRouter, OpenAI, Gemini through a Google AI Studio key, local; Kimi K3.1 Pro through OpenRouter is offered by Detect; a backend chosen as the Extractor takes a Deep-mode game's own files out into app/Original/ after the study) build with our own loop and the Build tools, trim and summarise long conversations and keep them in transcript.json, resumed only in the mode that saved it (one saved before the mode was kept counts as Deep); no live API build has been run yet.
  • Website checks compare the start page and up to 12 linked pages at the configured widths; the start page's menus, pop-ups and tabs are opened on the build too and compared in the note (the first few only, never menus inside menus or hover-only ones). Apps and games are checked by building and by a screenshot compared with the person's pictures (and the original's window when runtime study is on; then the build is also started normally, and its window and labelled controls are compared with the original's); games (and apps decompiled in Deep mode) also keep app/mechanics.json, which is checked for being readable and sourced, and fails while a number found in the original isn't used in the code (estimates may stay out). Every game must also pass its own --self-test (the build plays its core loop with scripted input and reports whether the player moved, acted and the HUD was drawn), and a Deep-mode game that uses the original's files must have app/CREDITS.md and the private-use line in app/README.md. The self-test is the build's own report: Craft Anything doesn't yet watch the game play or measure the values itself.
  • In Deep mode, app and game targets get a static study (triage, engine detection, file inventory, JS app graph, Ghidra when installed); in Clean room only the person's pictures and words. With runtime study on, the original is also started once for a picture of its window and its UI tree (Windows and macOS); it isn't driven or watched over time.
  • Several projects build at once ([build] parallel, 2 by default; Settings → Builds); more wait their turn. Queued builds start on their own as places come free, from MCP too. A build with an API key works alone, for now: it shares the app's session, so others wait for it and it for them.
  • Engine gaps from the audit: Frida session tools are partly simulated; imports outside the argument-count table show only the arguments set in the calling block. See tool-status.md.

Next

See ROADMAP.md for the ordered plan.

Build progress across runs

When app files can be compared, a build stops after two consecutive completed builder turns leave them unchanged. The versioned inbox/build-progress.json record keeps that count when the project is reopened or Try again is pressed. File contents and executable permissions decide progress, so rewriting identical bytes does not reset it. An actual app edit or a new nonempty request starts another attempt, including notes queued during a turn or check and notes consumed by a builder hook. Empty notes and plain Try again keep the saved count. Dependency/build caches, git metadata and Craft's own records, including checks in a project edited in place, do not count. Symlinks are recorded without following their targets. A successful check may still finish the second unchanged turn, and a run waiting only for checks does not start the builder again. Within a run, file digests are reused while size, modification time and executable bits match; Unix file identity and change time also invalidate a cached read. The first scan reads content, but unchanged imported assets are not read again before and after every turn. The metadata is only a cache key: rewriting identical bytes still produces the same content fingerprint. The cache is isolated by project root, drops deleted or retyped paths, and is discarded after scan errors or cancellation. It is not persisted, and the version-1 fingerprint/schema is unchanged. Sockets, pipes and devices contribute their names and types without opening their contents. If a scan cannot finish because of limits, permissions or changing files, the feed says why the unchanged-turn limit is skipped for that run. The saved fingerprint and count are cleared so a later readable run starts a fresh comparison. Checks and the existing round limit still apply. Cancellation still stops the run; completed builder replies are saved as awaiting checks before the post-turn scan. Broken or newer progress records and record-write failures remain errors.

A check round in which every check worked is kept (in memory, and as checked in the record once craft.json has the round). While nothing it looks at changes (the app's files as above, the names, sizes and times of reference/ and capture/, the kind, stack, mode, plugin checks and the project's folder), the next check, the builder's own rebuild_check included, takes its results instead of building and starting the app again, and the feed says so. A round with any failure is never kept, so Try again always looks again. Not run live.

Scripted API turns and executable CLI stand-ins cover the stop, persistence, fresh requests and check recovery. This change has not been verified with a paid model or a live provider. Copying a whole project keeps its progress record; Duplicate creates a new attempt with a fresh conversation and count, as it already does for usage. An existing root-level file or directory named build-progress.json remains app data: it is fingerprinted, copied by Duplicate and kept when Craft's project records are removed. Its JSON shape does not make it a Craft record, and it is never migrated into the inbox.

Notes consumed by builder hooks now only queue a progress reset while the turn is running. The reset is saved after the successful turn and its awaiting_check recovery state are persisted. Multiple consumed notes coalesce into one reset; blank notes do not reset the count. A broken or inaccessible progress record still returns its actual error at that safe boundary, without starting another provider request or losing the finished builder reply. If the turn fails or is cancelled after consuming a note, its reset is saved before the run ends so reopening keeps the new request's full allowance. The original failure or cancellation remains the result; a reset that cannot be saved is reported separately and never overwrites a broken or newer record. Scripted turns cover both outcomes, blank notes and unreadable records.

DNS answer name boundaries

Within the first 64 decoded answer/prerequisite records, NS, CNAME, PTR and MX values must be fully encoded inside their declared RDATA. DNS UPDATE RRset prerequisites may carry an empty value only with CLASS ANY/NONE and TTL zero; later prerequisite records are still decoded. Backward compression pointers still work, including names with a label before the pointer. A truncated name, missing MX preference or extra bytes after a name marks the DNS message incomplete and keeps that answer out of the packet and capture inventories. Earlier complete answers remain available. Eleven synthetic packet regressions cover those boundaries, root names, literal names, legal and malformed UPDATE prerequisites, and the summary inventory; no live capture was used.

Local model identifier task hints

Automatic local setup recognizes numeric suffixes on known embedding, reranking and speech task tokens. Generic GGUF filenames (ggml-model-*.gguf, ggml-model.gguf and model.gguf) also keep their immediate model directory as a task hint, with either path separator. Named model files, publisher prefixes and unrelated words are not classified by arbitrary ancestor directories. Regression tests cover mixed model lists and servers listing only specialised models through the local discovery API. Classification remains a name heuristic; it does not probe model capabilities.