@withbuddi/buddi 0.1.0-pre.46 → 0.1.0-pre.48

package/node_modules/imapflow/dist/esm/handler/token-parser.js

@@ -7,7 +7,6 @@ const STATE_NORMAL = 0x003;
 const STATE_PARTIAL = 0x004;
 const STATE_SEQUENCE = 0x005;
 const STATE_STRING = 0x006;
-const RE_DIGITS = /^\d+$/;
 const RE_SINGLE_DIGIT = /^\d$/;
 // Prevents stack overflow from maliciously crafted deeply-nested IMAP input (e.g., (((((...))))))
 const MAX_NODE_DEPTH = 25;
@@ -169,6 +168,63 @@ export class TokenParser {
                 i++;
             }
         };
+        // Whether chr is the closing delimiter of node: ")" ends a LIST, "]" ends a SECTION
+        const closesNode = (c, node) => !!node && ((c === ')' && node.type === 'LIST') || (c === ']' && node.type === 'SECTION'));
+        // Facts about the ATOM, SEQUENCE or PARTIAL token being read, kept up to date as its
+        // characters are appended. Reading them back from the value instead (value.at(-1),
+        // value.includes('*'), a regex test) makes V8 flatten the string built with += on every
+        // character, which is quadratic in the token length, and the server decides that length:
+        // a 600 KB ESEARCH result took seconds of event loop time
+        let tokenLength = 0;
+        let tokenLast = '';
+        let tokenPrev = '';
+        let tokenDigitsOnly = true;
+        let tokenHasStar = false;
+        let tokenHasDot = false;
+        const appendToToken = (c) => {
+            this.currentNode.value += c;
+            tokenLength++;
+            tokenPrev = tokenLast;
+            tokenLast = c;
+            tokenDigitsOnly = tokenDigitsOnly && RE_SINGLE_DIGIT.test(c);
+            tokenHasStar = tokenHasStar || c === '*';
+            tokenHasDot = tokenHasDot || c === '.';
+        };
+        // A digit-led token is only a guess at a sequence set. ":" and "," are ATOM-CHARs, so a
+        // server sends a mailbox name, keyword or label such as "2024:Q1" or "1,a" unquoted, and
+        // rejecting it would drop the whole response line: the mailbox missing from LIST, the
+        // message missing from FETCH. When the sequence grammar breaks, such a token is read on as
+        // an atom, and the atom rules decide whether the current character is acceptable. A token
+        // holding "*" can not be an atom ("*" is not an ATOM-CHAR), so it keeps the sequence errors
+        const continueAsAtom = () => {
+            this.currentNode.type = 'ATOM';
+            this.state = STATE_ATOM;
+            // read the current character again, in STATE_ATOM
+            i--;
+        };
+        // Starts the value of the current node as a new token, with its first character if any
+        const startToken = (first) => {
+            this.currentNode.value = '';
+            tokenLength = 0;
+            tokenLast = tokenPrev = '';
+            tokenDigitsOnly = true;
+            tokenHasStar = tokenHasDot = false;
+            if (first) {
+                appendToToken(first);
+            }
+        };
+        // ImapStream supplies one buffer per literal marker it framed, {0} included. A marker
+        // without a buffer means the line and its literals do not match up, so fail with a parser
+        // error instead of reading a missing buffer or shifting every later literal by one
+        const takeLiteral = (literals) => {
+            if (!literals.length) {
+                let error = new Error(`Literal without data at position ${this.pos + i} [E35]`);
+                error.code = 'ParserError35';
+                error.parserContext = { input: this.str, pos: this.pos + i, chr };
+                throw error;
+            }
+            return literals.shift();
+        };
         // Any ATOM supported char starts a new Atom sequence, otherwise throw an error
         // Allow \ as the first char for atom to support system flags
         // Allow % to support LIST '' %
@@ -184,7 +240,7 @@ export class TokenParser {
             }
             this.currentNode = this.createNode(this.currentNode, this.pos + i);
             this.currentNode.type = 'ATOM';
-            this.currentNode.value = chr;
+            startToken(chr);
             this.state = STATE_ATOM;
         };
         for (i = 0, len = this.str.length; i < len; i++) {
@@ -239,12 +295,13 @@ export class TokenParser {
                             if (this.str.charAt(i - 1) !== ']') {
                                 this.currentNode = this.createNode(this.currentNode, this.pos + i);
                                 this.currentNode.type = 'ATOM';
-                                this.currentNode.value = chr;
+                                startToken(chr);
                                 this.state = STATE_ATOM;
                             }
                             else {
                                 this.currentNode = this.createNode(this.currentNode, this.pos + i);
                                 this.currentNode.type = 'PARTIAL';
+                                startToken();
                                 this.state = STATE_PARTIAL;
                                 this.currentNode.isClosed = false;
                             }
@@ -254,12 +311,14 @@ export class TokenParser {
                         case '~': {
                             let nextChr = this.str.charAt(i + 1);
                             if (nextChr !== '{') {
-                                if (imapFormalSyntax['ATOM-CHAR']().includes(nextChr)) {
-                                    // '~' not followed by '{' but followed by an ATOM char: treat as ATOM
-                                    this.currentNode = this.createNode(this.currentNode, this.pos + i);
-                                    this.currentNode.type = 'ATOM';
-                                    this.currentNode.value = chr;
-                                    this.state = STATE_ATOM;
+                                // '~' is an ATOM-CHAR itself, so when it does not start a literal8
+                                // it starts an atom, including the one-character atom "~" that a
+                                // space, the end of the line or a closing delimiter ends
+                                if (imapFormalSyntax['ATOM-CHAR']().includes(nextChr) ||
+                                    nextChr === ' ' ||
+                                    nextChr === '' ||
+                                    closesNode(nextChr, this.currentNode)) {
+                                    startAtom();
                                     break;
                                 }
                                 let error = new Error(`Unexpected literal8 marker at position ${this.pos + i} [E12]`);
@@ -285,7 +344,7 @@ export class TokenParser {
                         case '*':
                             this.currentNode = this.createNode(this.currentNode, this.pos + i);
                             this.currentNode.type = 'SEQUENCE';
-                            this.currentNode.value = chr;
+                            startToken(chr);
                             this.currentNode.isClosed = false;
                             this.state = STATE_SEQUENCE;
                             break;
@@ -366,8 +425,7 @@ export class TokenParser {
                         break;
                     }
                     // ')' or ']' terminates the atom AND closes the enclosing LIST or SECTION
-                    if (this.currentNode.parentNode &&
-                        ((chr === ')' && this.currentNode.parentNode.type === 'LIST') || (chr === ']' && this.currentNode.parentNode.type === 'SECTION'))) {
+                    if (closesNode(chr, this.currentNode.parentNode)) {
                         this.currentNode.endPos = this.pos + i - 1;
                         this.currentNode = this.currentNode.parentNode;
                         this.currentNode.isClosed = true;
@@ -403,14 +461,16 @@ export class TokenParser {
                     }
                     // If the atom so far is all digits and we see ',' or ':', it is actually
                     // a sequence set (e.g., "1:5" or "1,3,5"), so reclassify and switch state
-                    if ((chr === ',' || chr === ':') && RE_DIGITS.test(this.currentNode.value)) {
+                    if ((chr === ',' || chr === ':') && tokenLength && tokenDigitsOnly) {
                         this.currentNode.type = 'SEQUENCE';
                         this.currentNode.isClosed = true;
                         this.state = STATE_SEQUENCE;
                     }
                     // [ starts a section group for this element
                     // Allowed only for selected elements, otherwise falls through to regular ATOM processing
-                    if (chr === '[' && ['BODY', 'BODY.PEEK', 'BINARY', 'BINARY.PEEK'].includes(this.currentNode.value.toUpperCase())) {
+                    if (chr === '[' &&
+                        tokenLength <= 11 &&
+                        ['BODY', 'BODY.PEEK', 'BINARY', 'BINARY.PEEK'].includes(this.currentNode.value.toUpperCase())) {
                         this.currentNode.endPos = this.pos + i;
                         this.currentNode = this.createNode(this.currentNode.parentNode, this.pos + i);
                         this.currentNode.type = 'SECTION';
@@ -435,7 +495,7 @@ export class TokenParser {
                         error.parserContext = { input: this.str, pos: this.pos + i, chr };
                         throw error;
                     }
-                    this.currentNode.value += chr;
+                    appendToToken(chr);
                     break;
                 case STATE_STRING:
                     // DQUOTE ends the string sequence
@@ -462,7 +522,7 @@ export class TokenParser {
                     break;
                 case STATE_PARTIAL:
                     if (chr === '>') {
-                        if (this.currentNode.value.at(-1) === '.') {
+                        if (tokenLast === '.') {
                             let error = new Error(`Unexpected end of partial at position ${this.pos + i} [E19]`);
                             error.code = 'ParserError19';
                             error.parserContext = { input: this.str, pos: this.pos + i, chr };
@@ -475,7 +535,7 @@ export class TokenParser {
                         checkSP();
                         break;
                     }
-                    if (chr === '.' && (this.currentNode.value === '' || this.currentNode.value.includes('.'))) {
+                    if (chr === '.' && (!tokenLength || tokenHasDot)) {
                         let error = new Error(`Unexpected partial separator . at position ${this.pos + i} [E20]`);
                         error.code = 'ParserError20';
                         error.parserContext = { input: this.str, pos: this.pos + i, chr };
@@ -487,13 +547,13 @@ export class TokenParser {
                         error.parserContext = { input: this.str, pos: this.pos + i, chr };
                         throw error;
                     }
-                    if ((this.currentNode.value === '0' || this.currentNode.value.endsWith('.0')) && chr !== '.') {
+                    if (tokenLast === '0' && (tokenLength === 1 || tokenPrev === '.') && chr !== '.') {
                         let error = new Error(`Invalid partial at position ${this.pos + i} [E22: ${JSON.stringify(chr)}]`);
                         error.code = 'ParserError22';
                         error.parserContext = { input: this.str, pos: this.pos + i, chr };
                         throw error;
                     }
-                    this.currentNode.value += chr;
+                    appendToToken(chr);
                     break;
                 case STATE_LITERAL:
                     if (this.currentNode.started) {
@@ -544,12 +604,10 @@ export class TokenParser {
                         if (!this.currentNode.literalLength) {
                             // special case where literal content length is 0
                             // close the node right away, do not wait for additional input
-                            if (this.options.literals && this.options.literals.length) {
-                                // ImapStream queues a Buffer for every literal marker it
-                                // extracts, including {0} - consume the queue entry so
-                                // subsequent literals in the same response stay aligned
-                                // with their markers instead of shifting by one
-                                this.currentNode.value = this.options.literals.shift();
+                            if (this.options.literals) {
+                                // consume the queue entry of the {0} marker too, so later
+                                // literals in the same response stay aligned with their markers
+                                this.currentNode.value = takeLiteral(this.options.literals);
                             }
                             this.currentNode.endPos = this.pos + i;
                             this.currentNode.isClosed = true;
@@ -559,7 +617,7 @@ export class TokenParser {
                         }
                         else if (this.options.literals) {
                             // use the next precached literal values
-                            this.currentNode.value = this.options.literals.shift();
+                            this.currentNode.value = takeLiteral(this.options.literals);
                             // only APPEND arguments are kept as Buffers
                             /*
                             if ((this.parent.command || '').toString().toUpperCase() !== 'APPEND') {
@@ -614,19 +672,24 @@ export class TokenParser {
                     }
                     this.currentNode.literalLength = (this.currentNode.literalLength || '') + chr;
                     break;
-                case STATE_SEQUENCE:
-                    // space finishes the sequence set
-                    if (chr === ' ') {
-                        if (!RE_SINGLE_DIGIT.test(this.currentNode.value.at(-1)) && this.currentNode.value.at(-1) !== '*') {
-                            let error = new Error(`Unexpected whitespace at position ${this.pos + i} [E27]`);
+                case STATE_SEQUENCE: {
+                    // A space ends the sequence set, and so does the closing delimiter of the
+                    // enclosing list or section ("PARTIAL (1:100 5,7,9)", "[COPYUID 1 1:3 4,5]")
+                    let closesParent = closesNode(chr, this.currentNode.parentNode);
+                    if (chr === ' ' || closesParent) {
+                        if (!RE_SINGLE_DIGIT.test(tokenLast) && tokenLast !== '*') {
+                            if (!tokenHasStar) {
+                                // a dangling separator, "10:" or "1,"
+                                continueAsAtom();
+                                break;
+                            }
+                            let error = new Error(`Unexpected end of sequence at position ${this.pos + i} [E27: ${JSON.stringify(chr)}]`);
                             error.code = 'ParserError27';
                             error.parserContext = { input: this.str, pos: this.pos + i, chr };
                             throw error;
                         }
-                        if (this.currentNode.value !== '*' &&
-                            this.currentNode.value.at(-1) === '*' &&
-                            this.currentNode.value.at(-2) !== ':') {
-                            let error = new Error(`Unexpected whitespace at position ${this.pos + i} [E28]`);
+                        if (this.currentNode.value !== '*' && tokenLast === '*' && tokenPrev !== ':') {
+                            let error = new Error(`Unexpected end of sequence at position ${this.pos + i} [E28: ${JSON.stringify(chr)}]`);
                             error.code = 'ParserError28';
                             error.parserContext = { input: this.str, pos: this.pos + i, chr };
                             throw error;
@@ -635,20 +698,20 @@ export class TokenParser {
                         this.currentNode.endPos = this.pos + i - 1;
                         this.currentNode = this.currentNode.parentNode;
                         this.state = STATE_NORMAL;
-                        break;
-                    }
-                    else if (this.currentNode.parentNode && chr === ']' && this.currentNode.parentNode.type === 'SECTION') {
-                        this.currentNode.endPos = this.pos + i - 1;
-                        this.currentNode = this.currentNode.parentNode;
-                        this.currentNode.isClosed = true;
-                        this.currentNode.endPos = this.pos + i;
-                        this.currentNode = this.currentNode.parentNode;
-                        this.state = STATE_NORMAL;
-                        checkSP();
+                        if (closesParent) {
+                            this.currentNode.isClosed = true;
+                            this.currentNode.endPos = this.pos + i;
+                            this.currentNode = this.currentNode.parentNode;
+                            checkSP();
+                        }
                         break;
                     }
                     if (chr === ':') {
-                        if (!RE_SINGLE_DIGIT.test(this.currentNode.value.at(-1)) && this.currentNode.value.at(-1) !== '*') {
+                        if (!RE_SINGLE_DIGIT.test(tokenLast) && tokenLast !== '*') {
+                            if (!tokenHasStar) {
+                                continueAsAtom();
+                                break;
+                            }
                             let error = new Error(`Unexpected range separator : at position ${this.pos + i} [E29]`);
                             error.code = 'ParserError29';
                             error.parserContext = { input: this.str, pos: this.pos + i, chr };
@@ -656,7 +719,7 @@ export class TokenParser {
                         }
                     }
                     else if (chr === '*') {
-                        if (![',', ':'].includes(this.currentNode.value.at(-1))) {
+                        if (![',', ':'].includes(tokenLast)) {
                             let error = new Error(`Unexpected range wildcard at position ${this.pos + i} [E30]`);
                             error.code = 'ParserError30';
                             error.parserContext = { input: this.str, pos: this.pos + i, chr };
@@ -664,13 +727,17 @@ export class TokenParser {
                         }
                     }
                     else if (chr === ',') {
-                        if (!RE_SINGLE_DIGIT.test(this.currentNode.value.at(-1)) && this.currentNode.value.at(-1) !== '*') {
+                        if (!RE_SINGLE_DIGIT.test(tokenLast) && tokenLast !== '*') {
+                            if (!tokenHasStar) {
+                                continueAsAtom();
+                                break;
+                            }
                             let error = new Error(`Unexpected sequence separator , at position ${this.pos + i} [E31]`);
                             error.code = 'ParserError31';
                             error.parserContext = { input: this.str, pos: this.pos + i, chr };
                             throw error;
                         }
-                        if (this.currentNode.value.at(-1) === '*' && this.currentNode.value.at(-2) !== ':') {
+                        if (tokenLast === '*' && tokenPrev !== ':') {
                             let error = new Error(`Unexpected sequence separator , at position ${this.pos + i} [E32]`);
                             error.code = 'ParserError32';
                             error.parserContext = { input: this.str, pos: this.pos + i, chr };
@@ -678,20 +745,29 @@ export class TokenParser {
                         }
                     }
                     else if (!RE_SINGLE_DIGIT.test(chr)) {
+                        if (!tokenHasStar) {
+                            continueAsAtom();
+                            break;
+                        }
                         let error = new Error(`Unexpected char at position ${this.pos + i} [E33: ${JSON.stringify(chr)}]`);
                         error.code = 'ParserError33';
                         error.parserContext = { input: this.str, pos: this.pos + i, chr };
                         throw error;
                     }
-                    if (RE_SINGLE_DIGIT.test(chr) && this.currentNode.value.at(-1) === '*') {
+                    if (RE_SINGLE_DIGIT.test(chr) && tokenLast === '*') {
                         let error = new Error(`Unexpected number at position ${this.pos + i} [E34: ${JSON.stringify(chr)}]`);
                         error.code = 'ParserError34';
                         error.parserContext = { input: this.str, pos: this.pos + i, chr };
                         throw error;
                     }
-                    this.currentNode.value += chr;
+                    appendToToken(chr);
                     break;
+                }
             }
         }
+        // the same applies to a digit-led token that ends the input on a dangling separator ("10:")
+        if (this.state === STATE_SEQUENCE && (tokenLast === ':' || tokenLast === ',') && !tokenHasStar) {
+            this.currentNode.type = 'ATOM';
+        }
     }
 }

package/node_modules/imapflow/dist/esm/package-info.d.ts

@@ -1,3 +1,3 @@
 export declare const name = "imapflow";
-export declare const version = "2.2.5";
+export declare const version = "2.2.6";
 export declare const homepage = "https://imapflow.com/";

package/node_modules/imapflow/dist/esm/package-info.js

@@ -1,4 +1,4 @@
 // Generated by scripts/build.js from package.json. Do not edit by hand.
 export const name = "imapflow";
-export const version = "2.2.5";
+export const version = "2.2.6";
 export const homepage = "https://imapflow.com/";

package/node_modules/imapflow/dist/esm/search-compiler.js

@@ -386,8 +386,12 @@ export const searchCompiler = (connection, query) => {
                     }
                     break;
                 // NOT operator
+                // A falsy operand means no NOT clause (`not: cond && {...}`). Any other one goes
+                // through walkOperand(), which refuses a value that is not a query object or
+                // compiles to nothing: dropping it would turn the filter into a search that
+                // matches everything
                 case 'NOT':
-                    if (params[term] && typeof params[term] === 'object') {
+                    if (params[term]) {
                         attributes.push({ type: 'ATOM', value: 'NOT' });
                         walkOperand('NOT', params[term]);
                     }
@@ -400,8 +404,8 @@ export const searchCompiler = (connection, query) => {
                         }
                         // Single element - just process it directly
                         if (params[term].length === 1) {
-                            if (typeof params[term][0] === 'object' && params[term][0]) {
-                                walk(params[term][0]);
+                            if (params[term][0]) {
+                                walkOperand('OR', params[term][0]);
                             }
                             break;
                         }

package/node_modules/imapflow/package.json

@@ -1,6 +1,6 @@
 {
     "name": "imapflow",
-    "version": "2.2.5",
+    "version": "2.2.6",
     "description": "IMAP Client for Node",
     "type": "module",
     "main": "./dist/cjs/imap-flow.js",
@@ -45,6 +45,7 @@
         "pretest:workers": "npm run build",
         "test:workers": "node --import tsx --test test/cloudflare/cloudflare-test.ts",
         "test:rev2": "bash test/integration/run-rev2-tests.sh",
+        "test:mutation": "node scripts/mutation-test.js",
         "format": "prettier --write \"**/*.{js,cjs,ts,json,md,yml,yaml}\"",
         "format:check": "prettier --check \"**/*.{js,cjs,ts,json,md,yml,yaml}\"",
         "lint": "npm run typecheck && eslint .",
@@ -77,7 +78,7 @@
         "tsx": "4.23.15",
         "types-node-legacy": "npm:@types/node@20.0.0",
         "typescript": "6.0.3",
-        "typescript-eslint": "8.71.0",
+        "typescript-eslint": "8.71.1",
         "wrangler": "4.147.0"
     },
     "dependencies": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@withbuddi/buddi",
-  "version": "0.1.0-pre.46",
+  "version": "0.1.0-pre.48",
   "type": "module",
   "description": "Your personal agents, on your computer",
   "repository": {
@@ -17,7 +17,7 @@
     "buddi": "packages/install/dist/launcher.js"
   },
   "buddi": {
-    "notes": "### Added\n\n- Plugin pages can hide just the figures: a page query may name the values that are sensitive (a balance, a total) instead of hiding everything that reads it. The page then shows its whole layout with those values as •••• and one \"Show amounts\" button in its head, which reveals the page (and the next one) until you switch to another app or tab, or five minutes pass. Showing or hiding amounts never empties a form you are typing in, and a field still showing •••• cannot be saved, in a form, a row's sheet or an editor alike. Over MCP, `buddi.page_query` returns those values as \"(hidden)\" unless asked with `includeSensitive`. (Host API 1.31.)\n\n### Changed\n\n- Canvas tabs in long conversations: a tab is now known by the tool and what it was about (a file, an account, a page, a site), titled \"Staged import · savings.csv\" instead of by the tool alone. Two files with the same name in different folders get a tab each. A repeat call on the same subject updates that tab and keeps the earlier results one step back inside it. The strip holds three tabs, most recently looked at first; the rest are a scrollable timeline (Now / Earlier this turn / Earlier) with Close others and Close all. A staged result past its expiry closes itself and a failure with nothing to show moves into the timeline; their chat rows still open them. Closed tabs and the order are kept per conversation by buddi, not in the browser.\n\n### Fixed\n\n- Agents can download files in the browser. A CFO on a bank site could not get a transactions CSV: buddi's own browser cancelled every download. Now a file an agent's click downloads goes into your Files (\"Downloaded from bank.example\", credited to the agent), and the agent gets its id to hand to the plugin that imports it. At most 50 MB a file and 500 MB per agent (a bigger one is refused and the agent says why), never executable; Files keeps the only copy. Settings → Browser & apps → Downloads shows any file that could not be filed and is waiting (cleared after 30 days), with Clear. In your Chrome, press Allow downloads in the buddi extension's popup once: then downloads an agent's click starts are picked up too, and the ones you start yourself are never touched.\n- Agents' downloads are held to tighter rules. In buddi's own browser a download is stopped the moment it passes 50 MB or runs past five minutes, and when the run is cancelled, instead of first downloading all of it; Chromium's copy is deleted once the file was filed or refused. In your Chrome, a download is read only from Chrome's download folder (`~/Downloads`, or the browser setting `downloadsFolder`), never through a linked folder, a dot-folder or buddi's own data, and the file checked is the file read. A site an agent visited earlier no longer makes your own download from it look like the agent's: each agent action counts only its own sites, for its own 15 seconds.\n- Settings → Browser & apps → Downloads lists each file waiting there (name, agent, day) with File it, which puts it in your Files; Clear asks first and says these copies are not in Files.\n- Reading a long file no longer overflows the reply: `artifacts.text` returns at most 16 KB and says how much there was (\"16 KB of 35 KB; use artifacts.describe or the plugin's import tool\"), and agents are told that a statement or CSV goes to the owning plugin's import tool, not into their answer.\n\n- The chat sends files on their own: drop three statements, press Enter, and they go with no words needed. An empty box with nothing attached still sends nothing.\n- The chat takes files while the agent is working. They used to be refused (\"Send files once the agent has answered.\"); now they queue with the words, the agent picks them up at its next step, or they open the next turn when the answer is already being written. A file can also be sent on its own mid-run. The box says where it goes in a full sentence under itself, and the bubble reads \"Queued with 1 file\".\n- Plugin pages update when the plugin's own tools write: after the CFO records balances in chat, an open Money page shows them within a second instead of still saying \"Start with one account\"; a form you are filling in keeps what you typed. It works for every plugin, whether the agent ran in chat, on Telegram or in a mission."
+    "notes": "### Added\n\n- Plugins that run models on this computer share one engine that buddi downloads only when it is first needed, for this platform only, instead of each plugin carrying its own 200 MB copy for every platform. The first plugin to need it shows one card (\"Download the Whisper base model (135 MB) and the engine that runs it (114 MB)?\"); later plugins use it without asking. The download is checked against a checksum pinned in buddi before anything is kept or loaded. Settings → System → Local models shows the engine (state, version, size) and the models plugins keep there, each with Remove. Linux x64 and arm64 and Apple silicon Macs; not available on Windows or Intel Macs yet (the Intel build is held back until it has been checked on one). Models run in a worker thread of their own, so a long transcription never freezes the dashboard, Telegram or other plugins. (Host API 1.32: `uses: ['onnx']`, `ctx.buddi.onnx`, `ctx.buddi.models`.)\n- When an agent proposes a schedule (or an agent package adds a mission) that will use your Chrome, the card says so in one line right under the ask, like \"Runs every day at 07:00, using your Chrome for PNC\", and approving it grants exactly that. Agents can say so themselves (`browser: 'owner'` in `schedule.propose`); otherwise buddi works it out when the plan names a site on your \"needs my sign-in\" list. Nothing gets your Chrome silently.\n- Missions: a mission that looks at pages shows \"Uses your Chrome\" or \"Own browser\", with a switch to change it either way.\n\n### Fixed\n\n- Local-model downloads follow the same address rules as every other fetch: no private or local addresses (also after a redirect or through DNS), no credentials in the address, only the web's own ports, at most five redirects.\n- A failed local-model download no longer logs, keeps or shows the full address it failed on; the reason names the host only, with any stored secret scrubbed.\n- Two models downloading at the same time no longer delete each other's half-finished files; a download a restart cut short resumes on the next ask without a second card, and its leftovers are cleaned up at start.\n- Two plugins asking for the engine at the same moment get one card between them, and that card now reaches Telegram and push, headed with its question (an owner secret's card too).\n- Closing a local-model session while it is still loading no longer leaves the model loaded.\n- Settings → Local models asks before removing a ready engine (\"Plugins that use it will ask you again\").\n- A mission run that needed your Chrome now stops there for real: nothing after it runs, so \"nothing was read or changed\" is always true and no other approval can jump ahead of the Chrome card.\n- Approving a schedule where buddi worked out that it needs your Chrome no longer fails as \"the effect changed\".\n- An agent can no longer ask for your Chrome for a mission that never browsed; when an agent (not a stopped run) asks, the card says the agent asks. Allow on a mission that is off or ended only grants it, runs nothing, and the card says so.\n\n### Changed\n\n- A scheduled mission that needs your signed-in Chrome no longer tells you to \"ask me in a normal chat\" to change it. The run stops without opening anything and you get one card, \"Let the PNC pull use your Chrome?\", saying nothing was read or changed and when it last brought you something, with Allow and Not now, on Home, in chat and on Telegram. Allow lets that mission use your Chrome from now on and runs it once straight away; Not now leaves it as it was. While the card is open, another refused run does not ask again."
   },
   "files": [
     "packages",