A session that opened project A and then B kept A's ledger and open questions: open_project loaded B's records into the same ledger. The desktop app has one engine for its lifetime, and each rebuild opens its project's investigation, so B's report and evidence tools mixed both projects.
Opening a different project now clears the session ledger, its order, open questions and unloaded count before loading the new project's store. Reopening the same project still refreshes it in place, and a failed unknowns read leaves the current project untouched. unloaded_evidence is recomputed on every open.
Regression: two projects with stored evidence and an open question; switching shows only the new project's records, reopening the same project keeps its ledger, and reopening the first restores its records. A follow-up roadmap line records the open targets and annotations that still survive a switch.
A session that opens a second project currently keeps the first project's evidence and open questions in the ledger. Record the pending change before fixing it.
Follow-up to #1949. A script that runs the headless launcher is kept as the launcher even when it sits in Ghidra's own folder, so what it sets up (its Java, say) isn't dropped. A path a start script names is also followed through its links, so a script that runs a linked ghidraRun leads to the Ghidra folder.
Recovering `with ({undefined: 42}) { result = void 0; }` rewrote `void 0` to `undefined`, which the `with` object can supply, changing the result. Files containing a `with` statement keep their `void` expressions; other rewrites stay on.
The lexer fallback reported `const hook = trpc.users.list.useQuery` as a client call although it only reads a property. An opening call parenthesis (or an optional call) is now required.
The lexer fallback read `require("./\141pp.js")` as a different module path and mis-decoded zero-padded braced Unicode escapes. Legacy octal escapes, every escaped line terminator and braced escapes of any length are now decoded, with checked arithmetic.
A comment between an operation keyword and its name hid the name, and a parenthesis inside a header comment could hide the whole operation. Comments and ignored separators are now skipped before header tokens are read.
A script whose type only resembled a JavaScript type (`application/javascript123`, or one with parameters such as `module; charset=utf-8`) was reported as executable. Types are now matched against the complete supported names, keeping `text/javascript1.0` to `1.5`, as browsers do.
Ghidra's guided setup unpacks Java into the engine store's `jdk` folder, but the Java runtime engine was looked for under `java`, so after that setup the listing still said Java wasn't installed and tools that run a jar (Vineflower, Apktool's check) refused. A guided install now names its store folder in the engine table, and the lookup and installs use it; a test keeps two engines from sharing a store folder.
Each change to an AI's tool list runs as its own job, and jobs can finish in any order, so two quick changes could leave Settings showing the first while the second was saved. The row now waits for its save, as the request-rate row does. Also escapes the `|` characters that split the STATUS table row.
* Take target file signatures from the shared craft-sniff table
* Pin craft-sniff to the craft-libs #1841 merge and record the cutover
The shared table is on main at 070005125f0af1a5ae4a59002270e5849505bfc0.
* Keep named-but-unsupported formats as Unknown
A CPIO file starting 070701 was identified by craft-sniff, then fell
through to the unsigned path and was called text. Identified kinds this
app does not inspect stay Unknown; the unsigned fallback is only for
files with no signature.
A Ghidra folder setting that named a file was run as the headless launcher whatever it was. A start script for Ghidra's window (as Linux packages put on PATH) was listed as found, failed as a launcher, and Deep mode quietly used the built-in decompiler. A file is now run only when it is the headless launcher or a script that runs it; a link or start script is followed to its Ghidra folder; any other file isn't listed as Ghidra.
Follow-up to #1941. Where a program is about to start or be checked (Play, making a pin, the build's run and screenshot checks), Cargo itself is asked for its target directory, which also covers CARGO_BUILD_TARGET_DIR, the Cargo home's config and a parent workspace's target folder. The Project screen keeps the file lookup, so it starts no process; without Cargo the result is the file lookup. Outside the project only a program the manifests name is taken.
An API backend's `tools` setting (auto, lean or full) could only be changed by editing config.toml. Settings → AI now has a "Builder's tools" choice per API backend, with a caption saying what Auto works out to for that AI, and `ai tools <name> [auto|lean|full]` shows or sets it from the CLI. Auto is saved as no setting; agent apps are refused, as they choose their own tools.
Docs only: the guided install was tried on a clean Debian 13 and a Debian 13 desktop, followed by a Deep-mode decompile. macOS stays open, and a new roadmap line records that a Ghidra folder setting naming a file is listed as found while Deep mode quietly uses the built-in engine.
A build on an API model refuses every tool that needs consent outside the Build tools without asking anyone, and the model was told "The user said no", so it made up a reason (#1938). The model is now told that nobody was asked and that a plugin's `consent` setting decides; the journal records the case as `refused`. Whether such a build should ask the person is left as a decision line in the roadmap.
The file lookup from #1941 stays for frequent reads (the Project screen). Where a
program is about to start or be checked (Play, pins, the build's run and
screenshot checks), launch_now also runs cargo metadata from the project and
looks in its target_directory first, which covers what the files don't:
$CARGO_HOME/config.toml, CARGO_BUILD_TARGET_DIR and a parent workspace's
target/. Outside the project, only a program the manifests name is taken.
The guided install (Ghidra 12.1.4 and its Java, through engines_install) on a
clean Debian 13 and a Debian 13 desktop, then a Deep-mode decompile from Ghidra.
Ghidra laid out as Arch-based packages install it is found (#85). New open line:
a Ghidra folder setting naming the /usr/bin/ghidra start script is listed as
found, but Deep mode quietly uses the built-in lifter.
A shared or ancestor target directory outside app now supplies only a program the manifests name. Without a name, only target directories inside app are searched, so another project's executable isn't started. built_program_in(app, env) makes the tests independent of the process's CARGO_TARGET_DIR.
The ancestor walk starts from a normalized absolute app, so a relative app reaches a config above the working directory; normalized paths also keep .. out of selected programs. Cargo's legacy config wins over config.toml when it exists, and a config without the key or with invalid TOML doesn't fall through.
A pin copies a program built outside app into pin-program/ and records that relative path; other executables in a shared folder are not copied, and the frozen pin keeps working when the external build is removed.
A project whose Cargo settings move the build output (build.target-dir in .cargo/config.toml, or CARGO_TARGET_DIR) built, but Play and the screenshot/self-test checks only looked in app/target, so they could not start the program. built_program now looks under CARGO_TARGET_DIR, then the closest project or ancestor .cargo setting, then the default target/ as a fallback, and starts the first target directory that has the named program.
The new AI regression uses a project with target-dir = "out" and fails before the fix; engine tests cover the environment path (relative and absolute), a project setting, an ancestor setting, the environment coming first, and the default fallback.
The process and UI source-policy gates stopped at a file's first test attribute, so production code below an interleaved test module escaped them. They now read Rust paths through the whole file, follow import aliases, ignore comments and string examples, and exempt only items that can't exist outside tests. The lock gate uses the same scope, and module files named by a path attribute are checked wherever they live.
A failed API-backend turn wrote the error's message to its log, and that message repeats what the service, or a proxy in front of it, answered, which can include the key or words from the request. The log now keeps our own code for the error, the HTTP status, the context window and request size, and the service's error code only when it is one of a known list. The error shown in the app and the CLI still has the service's message.