Evenfire is an intelligence layer platform for running LLM agents that take real actions, on your infrastructure
TypeScript
fix(mcp-host): keep removal charges through refused and undone removals
Alfredo Lopeze27107bfd601
diff --git a/docs/operations/gfs-large-file-host-downloads.md b/docs/operations/gfs-large-file-host-downloads.mdindex a23d6a088..d50d6b4b5 100644--- a/docs/operations/gfs-large-file-host-downloads.md+++ b/docs/operations/gfs-large-file-host-downloads.md@@ -448,20 +448,32 @@ removal keeps failing stays charged until it is removed. An indexed entry leftunder a trash name is dropped from the index, because its name is gone, and ischarged only on the trash name, never twice. An unindexed expired copy whoseremoval fails after the rename is charged on its trash name with the size read-from its `meta.json`. A directory the store holds no charge for when it-removes it (an unpublished transfer's partial, an unindexed incomplete-directory, or a trash directory left before this process started, since-charges are held in memory) is measured on its trash name (the bytes of its-regular files, symlinks not followed) and charged that size if its removal-fails. A tree that cannot be measured is logged and stays uncharged until a-later sweep measures it. When the rename itself fails, the directory keeps its-name: an indexed entry keeps its charge, and a directory with no charge is-measured the same way and charged under its own name. When the parent check-refuses after the rename and the rename back also fails, the refusal is-reported, the undo failure is logged as `GFS download store could not restore a-directory after refusing to remove it` with its error code, and a charge in-hand moves to the trash name; a trash directory in a refused parent is not-read to measure it.+from its `meta.json`. A failed transfer keeps its reservation as the charge of+whatever its removal leaves on disk, under its own name or a trash name. A+directory the store holds no charge for when it removes it (an unindexed+incomplete directory, or a trash directory left before this process started,+since charges are held in memory) is measured on its trash name (the bytes of+its regular files, symlinks not followed; each directory is checked again+when its turn comes, so one that is not a real directory then, such as a+symlinked `.gfs-downloads` or a child replaced by a symlink during the walk,+measures zero) and charged that size if its removal fails. A tree that cannot+be measured is logged and stays uncharged until a later sweep measures it.+When a removal leaves the directory under its own name (the rename failed, the+parent check refused before it, or a refusal after it was undone by renaming+it back), an indexed entry keeps its own charge and is never charged a second+time, and a charge in hand stays on the directory. A directory with no charge+is measured the same way and charged under its own name if its parent passes+the check again; one whose parent is still refused is not read and stays+uncharged until a later removal finds the parent safe. When the parent check+refuses after the rename and the rename back also+fails, the refusal is reported (a replaced `.gfs-downloads` refuses the+admission with `workspace_unavailable`), the undo failure is logged as `GFS+download store could not restore a directory after refusing to remove it` with+its error code, and a charge in hand moves to the trash name; a trash directory+in a refused parent is not read to measure it. Measuring walks the tree inside+the store's lock, so a large tree planted under a store name delays other+admissions and sweeps for the walk (about 12 µs per entry); it never fails+them.### Retention pins and cold resume@@ -531,9 +543,11 @@ user what happened and what they can do:who can finish or cancel their own running tasks to free space sooner andthen try again. It never acts on another user's tasks or files. The textoffers no deletion of downloaded copies, because that cannot admit the- download: the budget refusal comes only when evicting every copy no running- task protects would still not make room (the store then evicts nothing), and- the per-caller cap is checked before any eviction and counts only the copies+ download: the budget refusal comes when evicting every copy no running task+ protects would still not make room (the store then evicts nothing), or when a+ planned eviction fails to remove a copy (the copies already removed stay+ removed, and the one left on disk stays charged until a sweep removes it).+ The per-caller cap is checked before any eviction and counts only the copiesthe caller's running tasks protect.`volume_unmeasurable` carries no guidance: the volume could not be measured,diff --git a/mcp-host/package-lock.json b/mcp-host/package-lock.jsonindex 246e267a7..a89a6130b 100644--- a/mcp-host/package-lock.json+++ b/mcp-host/package-lock.json@@ -1,12 +1,12 @@{"name": "clerum-mcp-host",- "version": "0.1.546",+ "version": "0.1.547","lockfileVersion": 3,"requires": true,"packages": {"": {"name": "clerum-mcp-host",- "version": "0.1.546",+ "version": "0.1.547","license": "SEE LICENSE IN LICENSE","dependencies": {"@anthropic-ai/sdk": "^0.32.0",diff --git a/mcp-host/package.json b/mcp-host/package.jsonindex 3e069b976..b6166a820 100644--- a/mcp-host/package.json+++ b/mcp-host/package.json@@ -1,6 +1,6 @@{"name": "clerum-mcp-host",- "version": "0.1.546",+ "version": "0.1.547","description": "MCP Host - reads Host CRD and provides LLM access via OpenAI/Claude","main": "dist/main.js","engines": {diff --git a/mcp-host/src/internalTools/gfsDownloadStore.ts b/mcp-host/src/internalTools/gfsDownloadStore.tsindex 193a36533..de910a039 100644--- a/mcp-host/src/internalTools/gfsDownloadStore.ts+++ b/mcp-host/src/internalTools/gfsDownloadStore.ts@@ -401,15 +401,19 @@ async function sha256FileHandle(handle: fs.FileHandle, assertActive?: () => void}/**- * Regular files and their bytes under a directory, for the retirement log- * only. Nothing is opened and no symlink is followed: entries are classified- * by their own lstat type.+ * Regular files and their bytes under a directory, for the retirement log and+ * for charging a directory the store removes with no charge in hand. Nothing+ * is opened and no symlink is followed, the root included: a path that is not+ * a real directory when its turn comes, including one replaced by a symlink+ * after it was listed, holds no bytes of its own, and files are classified by+ * their own lstat type.*/async function treeUsage(root: string): Promise<{ files: number; bytes: number }> {const usage = { files: 0, bytes: 0 }const pending = [root]while (pending.length > 0) {const directory = pending.pop()!+ if (!(await fs.lstat(directory)).isDirectory()) continuefor (const entry of await fs.readdir(directory, { withFileTypes: true })) {const child = path.join(directory, entry.name)if (entry.isDirectory()) pending.push(child)@@ -899,7 +903,12 @@ export class GfsDownloadStore {if (this.active.get(id) !== transfer) throw new GfsDownloadStoreError('download_busy')this.releaseActive(id)this.unpinId(id)- const result = await this.removeDirectory(transfer.directory, 'incomplete_removed')+ // The reservation becomes the charge of whatever the removal leaves on disk.+ const result = await this.removeDirectory(+ transfer.directory,+ 'incomplete_removed',+ transfer.sizeBytes+ )if (result === 'failed' || result === 'trashed')throw new GfsDownloadStoreError('storage_write_failed')})@@ -1357,6 +1366,21 @@ export class GfsDownloadStore {}}+ /**+ * Measures a directory a failed removal left under its own name. Its parent+ * is checked again first: one still refused is not read, and the directory+ * stays uncharged until a later removal finds the parent safe. The refusal+ * was already logged by the removal.+ */+ private async sizeInPlace(directory: string): Promise<number | undefined> {+ try {+ await this.assertRemovable(directory)+ } catch {+ return undefined+ }+ return this.sizeStray(directory)+ }+/*** A replaced `.gfs-downloads` is renamed to `.gfs-downloads.trash-<uuid>`* in its caller root; one a stopped removal left there still holds copies@@ -1552,6 +1576,11 @@ export class GfsDownloadStore {await verifyPrivateStoreDirectory(downloadsRoot)}+ private isIndexedDirectory(directory: string): boolean {+ for (const entry of this.entries.values()) if (entry.directory === directory) return true+ return false+ }+private idsUnder(downloadsRoot: string): string[] {return [...this.entries.values()].filter(entry => path.dirname(entry.directory) === downloadsRoot)@@ -1740,9 +1769,11 @@ export class GfsDownloadStore {* its code and counted; the next sweep retries what is still listed.** Retained bytes stay charged while they are on disk. The charge is- * `charge` when the caller gives one (an indexed entry's size), otherwise a- * held charge already on `directory` (a held duplicate or a trash directory- * an earlier removal left), otherwise the measured size of the trash. When+ * `charge` when the caller gives one (an indexed entry's size, a failed+ * transfer's reservation), otherwise a held charge already on `directory`+ * (a held duplicate or a trash directory an earlier removal left), otherwise+ * the measured size of the directory or its trash. A directory left under+ * its own name and not indexed is held with that charge. When* the rename to the trash name succeeds but* the trash is not removed, the charge moves to the trash name as a held* charge, so the old name's absence never releases it; it is released only@@ -1764,17 +1795,18 @@ export class GfsDownloadStore {{ component: GFS_DOWNLOAD_STORE_LOG_COMPONENT, code: errorCode(error) },'GFS download store could not remove a download directory; the next sweep retries it')- if (error instanceof KeptInPlaceError) {- // Still under its own name. With no charge in hand (a stray trash, an- // unindexed partial, a failed transfer) it is measured and held here;- // a caller's charge stays with its indexed entry.- if (carried === undefined) {- const kept = await this.sizeStray(directory)+ if (!(error instanceof TrashLeftError)) {+ // Still under its own name: the rename failed, the parent check+ // refused before it, or a refusal after it was undone. An indexed+ // entry keeps its own charge. Otherwise a charge in hand (a failed+ // transfer's reservation, a held charge) stays on the directory; with+ // none, the directory is measured if its parent passes the check now.+ if (!this.isIndexedDirectory(directory)) {+ const kept = carried ?? (await this.sizeInPlace(directory))if (kept !== undefined) this.held.set(directory, { sizeBytes: kept })}return 'failed'}- if (!(error instanceof TrashLeftError)) return 'failed'this.held.delete(directory)// No charge in hand: the bytes the rename moved are measured on the// trash name when it passed the parent check. One the check refused isdiff --git a/mcp-host/src/internalTools/gfsDownloadStoreRemovalCharge.test.ts b/mcp-host/src/internalTools/gfsDownloadStoreRemovalCharge.test.tsindex 47be47d0b..1c93f081c 100644--- a/mcp-host/src/internalTools/gfsDownloadStoreRemovalCharge.test.ts+++ b/mcp-host/src/internalTools/gfsDownloadStoreRemovalCharge.test.ts@@ -17,6 +17,7 @@ import {completedCopy,digestOf,downloadDirectory,+ plantDownload,quotaCount,sourceFor,startTransfer,@@ -226,8 +227,9 @@ describe('GFS download store removal charges', () => {})expect(hits).toHaveLength(2)expect(storedBytes(hostRoot)).toBe(8 * MIB)- // Measured trees include meta.json, so the charge is at least the source bytes.- expect(view(store).charged).toBeGreaterThanOrEqual(8 * MIB)+ // Each reservation moved, unchanged, to the trash name its removal left.+ expect(view(store)).toMatchObject({ active: 0, held: 8 * MIB, charged: 8 * MIB })+ expect([...view(store).state.held.keys()].sort()).toEqual([...hits].sort())await expectRefused(store)await recoverAndWitness(store)}@@ -592,4 +594,256 @@ describe('GFS download store removal charges', () => {await store.fail(admitted.transfer.id, 'a')})++ it('RC-FAIL-PARENT-REFUSED: a failed transfer whose parent check refuses before the rename keeps its reservation charged', async () => {+ const store = await storeWithBudget()+ const a = await startTransfer(store, roots.a, 'a', 1, 4 * MIB)+ const b = await startTransfer(store, roots.b, 'b', 2, 4 * MIB)+ const faulted = new Set([+ path.join(roots.a, '.gfs-downloads'),+ path.join(roots.b, '.gfs-downloads'),+ ])+ const hits: string[] = []+ boundaries.realpath.mockImplementation(async (...args: unknown[]) => {+ if (faulted.has(String(args[0]))) {+ hits.push(String(args[0]))+ throw eio()+ }+ return Reflect.apply(nativeFs.realpath, nativeFs, args)+ })+ for (const [attempt, caller] of [+ [a, 'a'],+ [b, 'b'],+ ] as const)+ await expect(store.fail(attempt.transfer.id, caller)).rejects.toMatchObject({+ code: 'storage_write_failed',+ })+ expect(hits.length).toBeGreaterThanOrEqual(2)+ expect(storedBytes(hostRoot)).toBe(8 * MIB)+ expect(view(store)).toMatchObject({ entries: 0, active: 0, held: 8 * MIB, charged: 8 * MIB })+ await expectRefused(store)+ await recoverAndWitness(store)+ })++ it('RC-SYMLINK-ROOT: a .gfs-downloads symlink that cannot be removed is never walked into', async () => {+ const store = await storeWithBudget()+ const copy = await completedCopy(store, roots.b, 'b', 2, 4 * MIB, {+ owner: 'b-owner',+ expiresAt: new Date(Date.now() + 24 * HOUR).toISOString(),+ })+ const link = path.join(roots.a, '.gfs-downloads')+ syncFs.rmSync(link, { recursive: true, force: true })+ syncFs.symlinkSync(path.join(roots.b, '.gfs-downloads'), link)+ const renames: string[] = []+ boundaries.rename.mockImplementation((...args: unknown[]) => {+ if (String(args[0]) === link) {+ renames.push(String(args[0]))+ return Promise.reject(Object.assign(new Error('EACCES'), { code: 'EACCES' }))+ }+ return Reflect.apply(nativeFs.rename, nativeFs, args)+ })+ const walked: string[] = []+ boundaries.readdir.mockImplementation((...args: unknown[]) => {+ const target = String(args[0])+ if (target === link || target.startsWith(link + path.sep)) walked.push(target)+ return Reflect.apply(nativeFs.readdir, nativeFs, args)+ })+ for (let i = 0; i < 3; i++) await store.cleanupExpired()+ expect(renames).toHaveLength(3)+ expect(walked).toEqual([])+ expect(view(store)).toMatchObject({ held: 0, charged: 4 * MIB })+ expect((await store.readManagedFile(copy.receipt.path, 'b')).equals(copy.bytes)).toBe(true)+ })++ it('RC-REFUSED-TRASH-NOT-READ: a trash left in a refused parent with no charge in hand is not measured', async () => {+ const original = await storeWithBudget()+ await expiredTrash(original)+ await original.close(0)+ const downloads = new Set([+ path.join(roots.a, '.gfs-downloads'),+ path.join(roots.b, '.gfs-downloads'),+ ])+ const renamedInto = new Set<string>()+ const undone: string[] = []+ boundaries.rename.mockImplementation(async (...args: unknown[]) => {+ const from = String(args[0])+ const to = String(args[1])+ if (renamedInto.has(from)) {+ undone.push(from)+ throw eio()+ }+ const result = await Reflect.apply(nativeFs.rename, nativeFs, args)+ if (downloads.has(path.dirname(to))) renamedInto.add(to)+ return result+ })+ boundaries.realpath.mockImplementation(async (...args: unknown[]) => {+ const target = String(args[0])+ if (downloads.has(target) && renamedInto.size > undone.length) throw eio()+ return Reflect.apply(nativeFs.realpath, nativeFs, args)+ })+ const walked: string[] = []+ boundaries.readdir.mockImplementation((...args: unknown[]) => {+ if (renamedInto.has(String(args[0]))) walked.push(String(args[0]))+ return Reflect.apply(nativeFs.readdir, nativeFs, args)+ })+ const reopened = await storeWithBudget()+ expect(undone).toHaveLength(2)+ expect(walked).toEqual([])+ for (const trash of undone) expect(view(reopened).state.held.has(trash)).toBe(false)+ expect(storedBytes(hostRoot)).toBe(8 * MIB)+ await recoverAndWitness(reopened)+ })++ it('RC-ROOT-REFUSAL-CODE: a replaced .gfs-downloads whose undo fails reports the refusal and keeps its copies charged on the trash', async () => {+ const store = await storeWithBudget()+ await completedCopy(store, roots.a, 'a', 1, 4 * MIB, { owner: 'keep' })+ const downloads = path.join(roots.a, '.gfs-downloads')+ syncFs.chmodSync(downloads, 0o755)+ let trash: string | undefined+ boundaries.rename.mockImplementation(async (...args: unknown[]) => {+ const from = String(args[0])+ if (from === downloads) {+ trash = String(args[1])+ return Reflect.apply(nativeFs.rename, nativeFs, args)+ }+ if (trash !== undefined && from === trash) throw eio()+ return Reflect.apply(nativeFs.rename, nativeFs, args)+ })+ boundaries.realpath.mockImplementation(async (...args: unknown[]) => {+ if (trash !== undefined && String(args[0]) === roots.a) return '/elsewhere'+ return Reflect.apply(nativeFs.realpath, nativeFs, args)+ })+ await expect(startTransfer(store, roots.a, 'a', 2, 1024)).rejects.toMatchObject({+ code: 'workspace_unavailable',+ })+ expect(trash).toBeDefined()+ expect(view(store).state.held.get(trash!)?.sizeBytes).toBe(4 * MIB)+ expect(view(store)).toMatchObject({ entries: 0, charged: 4 * MIB })+ })++ it('RC-INDEXED-KEPT: an evicted entry whose rename fails stays indexed and is charged once', async () => {+ const store = await storeWithBudget()+ await completedCopy(store, roots.a, 'a', 1, 4 * MIB)+ await completedCopy(store, roots.b, 'b', 2, 4 * MIB)+ const hits: string[] = []+ boundaries.rename.mockImplementation((...args: unknown[]) => {+ const source = String(args[0])+ const cached = source.startsWith(roots.a) || source.startsWith(roots.b)+ if (cached && path.basename(source).startsWith('input-')) {+ hits.push(source)+ return Promise.reject(eio())+ }+ return Reflect.apply(nativeFs.rename, nativeFs, args)+ })+ // The plan evicts one of the two copies (the frozen clock ties them); its+ // rename fails, so the admission still exceeds the budget.+ for (let i = 0; i < 3; i++) {+ await expect(startTransfer(store, roots.c, 'c', 3 + i, 4 * MIB)).rejects.toMatchObject({+ code: 'host_quota_exceeded',+ })+ expect(view(store)).toMatchObject({ entries: 8 * MIB, held: 0, active: 0, charged: 8 * MIB })+ }+ expect(hits).toHaveLength(3)+ expect(storedBytes(hostRoot)).toBe(8 * MIB)+ restoreBoundary('rename')+ const fits = await startTransfer(store, roots.c, 'c', 6, 4 * MIB)+ // One copy is evicted now; the other and c's partial are what remains.+ expect(view(store)).toMatchObject({ entries: 4 * MIB, held: 0, active: 4 * MIB })+ expect(storedBytes(roots.a) + storedBytes(roots.b)).toBe(4 * MIB)+ expect(storedBytes(hostRoot)).toBe(8 * MIB)+ await store.fail(fits.transfer.id, 'c')+ })++ it('RC-UNDO-RESTORED-UNINDEXED: startup leftovers restored by an undone refusal are measured once their parent passes again', async () => {+ for (const caller of ['a', 'b'])+ plantDownload(roots[caller], { bytes: Buffer.alloc(4 * MIB), meta: 'omit' })+ // The check after each rename to a trash name fails once with EIO; the+ // rename back succeeds, so each leftover is under its own name again.+ const refused = new Set<string>()+ const undone: string[] = []+ boundaries.rename.mockImplementation(async (...args: unknown[]) => {+ const [from, to] = [String(args[0]), String(args[1])]+ const result = await Reflect.apply(nativeFs.rename, nativeFs, args)+ if (path.basename(from).startsWith('.trash-')) undone.push(to)+ else if (path.basename(to).startsWith('.trash-')) refused.add(path.dirname(to))+ return result+ })+ boundaries.realpath.mockImplementation(async (...args: unknown[]) => {+ if (refused.delete(String(args[0]))) throw eio()+ return Reflect.apply(nativeFs.realpath, nativeFs, args)+ })+ const store = await storeWithBudget()+ expect(undone).toHaveLength(2)+ expect(view(store)).toMatchObject({ entries: 0, held: 8 * MIB, charged: 8 * MIB })+ expect([...view(store).state.held.keys()].sort()).toEqual([...undone].sort())+ expect(storedBytes(hostRoot)).toBe(8 * MIB)+ // Each admission retries both removals, which are undone again.+ await expectRefused(store)+ expect(undone).toHaveLength(4)+ await recoverAndWitness(store)+ })++ it('RC-WALK-SWAP: a directory replaced by a symlink while a leftover is measured is not walked', async () => {+ const planted = plantDownload(roots.a, { bytes: Buffer.alloc(4 * MIB), meta: 'omit' })+ syncFs.mkdirSync(path.join(planted.directory, 'nested'))+ const victim = path.join(roots.b, 'ordinary-workspace-data')+ syncFs.mkdirSync(victim)+ const victimFile = path.join(victim, 'outside.bin')+ syncFs.writeFileSync(victimFile, Buffer.alloc(8 * MIB, 29))+ const swapped: string[] = []+ const walked: string[] = []+ boundaries.readdir.mockImplementation(async (...args: unknown[]) => {+ const target = String(args[0])+ walked.push(target)+ const listing = await Reflect.apply(nativeFs.readdir, nativeFs, args)+ // After the trash is listed, its child directory becomes a symlink.+ if (path.basename(target).startsWith('.trash-') && swapped.length === 0) {+ const nested = path.join(target, 'nested')+ syncFs.rmdirSync(nested)+ syncFs.symlinkSync(victim, nested)+ swapped.push(nested)+ }+ return listing+ })+ failTrashRemoval()+ const store = await storeWithBudget()+ expect(swapped).toHaveLength(1)+ expect(walked).not.toContain(swapped[0])+ expect(walked).not.toContain(victim)+ expect(view(store)).toMatchObject({ entries: 0, held: 4 * MIB, charged: 4 * MIB })+ // 4 MiB held plus 4 MiB requested fit the 10 MiB budget.+ const fits = await startTransfer(store, roots.c, 'c', 3, 4 * MIB)+ expect(view(store)).toMatchObject({ held: 4 * MIB, active: 4 * MIB })+ restoreBoundary('rm')+ await store.fail(fits.transfer.id, 'c')+ restoreBoundary('readdir')+ await recoverAndWitness(store)+ expect(syncFs.statSync(victimFile).size).toBe(8 * MIB)+ })++ it('RC-REFUSED-IN-PLACE-NOT-READ: a leftover whose parent check keeps failing is not walked to measure it', async () => {+ plantDownload(roots.a, { bytes: Buffer.alloc(4 * MIB), meta: 'omit' })+ const downloads = path.join(roots.a, '.gfs-downloads')+ const checks: string[] = []+ boundaries.realpath.mockImplementation(async (...args: unknown[]) => {+ if (String(args[0]) === downloads) {+ checks.push(downloads)+ throw eio()+ }+ return Reflect.apply(nativeFs.realpath, nativeFs, args)+ })+ const walked: string[] = []+ boundaries.readdir.mockImplementation((...args: unknown[]) => {+ if (path.basename(String(args[0])).startsWith('input-')) walked.push(String(args[0]))+ return Reflect.apply(nativeFs.readdir, nativeFs, args)+ })+ const store = await storeWithBudget()+ expect((await store.cleanupExpired()).removeFailed).toBe(1)+ // Refused before the rename and again by the recheck, in both sweeps.+ expect(checks.length).toBeGreaterThanOrEqual(4)+ expect(walked).toEqual([])+ expect(view(store)).toMatchObject({ entries: 0, held: 0 })+ expect(storedBytes(hostRoot)).toBe(4 * MIB)+ await recoverAndWitness(store)+ })})diff --git a/mcp-host/src/internalTools/gfsSpaceGuidance.ts b/mcp-host/src/internalTools/gfsSpaceGuidance.tsindex 14c2b9fbd..e9a186287 100644--- a/mcp-host/src/internalTools/gfsSpaceGuidance.ts+++ b/mcp-host/src/internalTools/gfsSpaceGuidance.ts@@ -14,10 +14,12 @@ export const GFS_DISK_FULL_GUIDANCE ="another user's directory or anything outside the workspace."// Deleting downloaded copies by hand cannot admit the download. The budget-// refusal comes only when evicting every copy no running task protects would-// still not make room, and the per-caller cap, checked before any eviction,-// counts only copies the caller's running tasks protect. Only tasks finishing-// (or being cancelled) and copies expiring free that space.+// refusal comes when evicting every copy no running task protects would still+// not make room, or when a planned eviction fails to remove a copy, which+// stays charged until a sweep removes it. The per-caller cap, checked before+// any eviction, counts only copies the caller's running tasks protect. Only+// tasks finishing (or being cancelled), copies expiring and sweeps free that+// space.export const GFS_CACHE_FULL_GUIDANCE ="The Host's cache of downloaded files is full, so the file was not downloaded. " +'Space frees as tasks finish and downloaded copies expire. Tell the user. ' +diff --git a/scripts/ci/pinned-vitest-cases/mcp-host.json b/scripts/ci/pinned-vitest-cases/mcp-host.jsonindex 4424e2c24..11e8f5fb8 100644--- a/scripts/ci/pinned-vitest-cases/mcp-host.json+++ b/scripts/ci/pinned-vitest-cases/mcp-host.json@@ -1203,6 +1203,38 @@"suite": "gfsDownloadStoreRemovalCharge.test.ts","fullName": "GFS download store removal charges RC-VOLUME-EIO-true: a rejected statfs propagates without treating it as an invalid reading"},+ {+ "suite": "gfsDownloadStoreRemovalCharge.test.ts",+ "fullName": "GFS download store removal charges RC-FAIL-PARENT-REFUSED: a failed transfer whose parent check refuses before the rename keeps its reservation charged"+ },+ {+ "suite": "gfsDownloadStoreRemovalCharge.test.ts",+ "fullName": "GFS download store removal charges RC-SYMLINK-ROOT: a .gfs-downloads symlink that cannot be removed is never walked into"+ },+ {+ "suite": "gfsDownloadStoreRemovalCharge.test.ts",+ "fullName": "GFS download store removal charges RC-REFUSED-TRASH-NOT-READ: a trash left in a refused parent with no charge in hand is not measured"+ },+ {+ "suite": "gfsDownloadStoreRemovalCharge.test.ts",+ "fullName": "GFS download store removal charges RC-ROOT-REFUSAL-CODE: a replaced .gfs-downloads whose undo fails reports the refusal and keeps its copies charged on the trash"+ },+ {+ "suite": "gfsDownloadStoreRemovalCharge.test.ts",+ "fullName": "GFS download store removal charges RC-INDEXED-KEPT: an evicted entry whose rename fails stays indexed and is charged once"+ },+ {+ "suite": "gfsDownloadStoreRemovalCharge.test.ts",+ "fullName": "GFS download store removal charges RC-UNDO-RESTORED-UNINDEXED: startup leftovers restored by an undone refusal are measured once their parent passes again"+ },+ {+ "suite": "gfsDownloadStoreRemovalCharge.test.ts",+ "fullName": "GFS download store removal charges RC-WALK-SWAP: a directory replaced by a symlink while a leftover is measured is not walked"+ },+ {+ "suite": "gfsDownloadStoreRemovalCharge.test.ts",+ "fullName": "GFS download store removal charges RC-REFUSED-IN-PLACE-NOT-READ: a leftover whose parent check keeps failing is not walked to measure it"+ },{"suite": "gfsDownloadStoreTrashAndExpiry.test.ts","fullName": "GFS download store: a copy left under a trash name stays charged (R5-F1) OPUS-R6-RESTART: after a Host restart a trash directory whose removal keeps failing is sized and charged again"