@@ -225,7 +225,10 @@ script that ran to its end, whatever its status; otherwise nothing is applied):
    the same Keep/Undo and per-turn checkpoint as `edit_file`. It answers `{ rest, notes, failed?, refused? }`; `rest`
    may only contain `mkdir`/`rmdir` entries **of this change set** (anything else is counted failed and named), which
    the shell applies with `workspace.fs`; an answer that is not an object with a `rest` list is "gave no answer";
-   `failed` must be a finite non-negative number. `notes` are appended to stderr.
+   `failed` must be a finite non-negative number: the file changes (writes and deletes) it could not apply. What the
+   result counts as applied is the set's files less `failed` and less anything else handed back, then the folders of
+   `rest` the shell made or removed; a folder the review keeps out of `rest` (shellCommit keeps the removal of one that a
+   file could not be deleted from) is applied by nobody and is not counted. `notes` are appended to stderr.
 2. **The visitor's terminal** (no `commit`): `src/commit.js` validates (inside the folders, size caps, entry cap),
    checks that nothing changed on disk since the command read it (read-only, bounded), and writes bytes with
    `workspace.fs` — creates, then deletes, deepest paths first, **never recursive and never to the trash** — and reports
 
@@ -1044,9 +1044,9 @@ function createRuntime(deps) {
 	 * workspace directly otherwise. Validated as a whole first in both cases.
 	 *
 	 * What the review hands back is trusted for what the contract says it is - `rest`, a list of the folders the
-	 * command made and removed, which this shell then makes and removes; `notes`; `failed`, a count - and no
-	 * more: an entry that is not one of those folders is not applied, an answer that is not that shape is "no
-	 * answer", and a count that is not a count is not believed.
+	 * command made and removed, which this shell then makes and removes; `notes`; `failed`, the count of file changes
+	 * it could not apply - and no more: an entry that is not one of those folders is not applied, an answer that is not
+	 * that shape is "no answer", and a count that is not a count is not believed.
 	 *
 	 * Time is bounded the same way in both routes (the gate): a call to the file system is waited for `fsMs` at most
 	 * and the part that writes has a budget in all - for the agent `commitMs` for the review and then the folders it
@@ -1103,11 +1103,16 @@ function createRuntime(deps) {
 			else { failed = total; notes.push(note('the review gave a count of changes it could not apply that is not a number, so none of them are counted as applied')); }
 		}
 		const handedBack = refused ? [] : r.rest;
-		let applied = refused ? 0 : Math.max(0, total - handedBack.length - failed);
 		// What the review leaves to the shell is the folders the command made and removed, and only those.
 		const folders = new Set(handed.filter((c) => c.kind === 'mkdir' || c.kind === 'rmdir').map((c) => c.kind + ' ' + c.path));
 		const rest = handedBack.filter((/** @type {any} */ c) => c && (c.kind === 'mkdir' || c.kind === 'rmdir') && folders.has(c.kind + ' ' + c.path));
 		const ignored = handedBack.length - rest.length;
+		// What the review applied is the files it was given, less the ones it could not apply and whatever else it handed
+		// back (what is handed back is still to be done). Folders are never its to apply: it hands back the ones this shell
+		// is to make and remove, and one it keeps back is applied by nobody (shellCommit keeps back the removal of a folder
+		// when a file in it could not be deleted), so it is not counted as applied.
+		const files = handed.filter((c) => c.kind === 'write' || c.kind === 'delete').length;
+		let applied = refused ? 0 : Math.max(0, files - failed - ignored);
 		if (ignored > 0) {
 			failed += ignored;
 			notes.push(note(ignored + ' entr' + (ignored === 1 ? 'y' : 'ies') + ' the review handed back to the shell ' + (ignored === 1 ? 'is' : 'are') + ' not ' + (ignored === 1 ? 'a folder' : 'folders') + ' the command made or removed, and ' + (ignored === 1 ? 'was' : 'were') + ' NOT applied'));
 
@@ -351,6 +351,47 @@ async function agent(rig, command, opts) {
 		r.rt.dispose();
 	});
 
+	await test('a review that fails one delete keeps the folder it was under: the shell counts what was applied (1 of 4), not the set less what failed', async () => {
+		// levelcode-ai's own review, its answer handed on as agent.js hands it on
+		const { commitShellChanges } = require(path.join(__dirname, '..', '..', '..', 'extensions', 'levelcode-ai', 'shellCommit.js'));
+		for (const how of ['the folder it leaves cannot be made', 'Stop while the folder it leaves is being made']) {
+			const r = createRig();
+			r.ws.put('/scratch/d/a.txt', 'a\n');
+			r.ws.put('/scratch/d/b.txt', 'b\n');
+			ending(r, { exitCode: 0, changes: [mkdir('/scratch/m'), del('/scratch/d/a.txt', 'a\n'), del('/scratch/d/b.txt', 'b\n'), rmdir('/scratch/d')] });
+			const ctx = {
+				applyEdit: async () => false,
+				applyDelete: async (/** @type {{ path: string }} */ o) => {
+					if (o.path === 'd/b.txt') { return false; }
+					await r.ws.fs.delete(r.ws.vscode.Uri.parse('levelcode-scratch:///scratch/' + o.path), { recursive: false });
+					return true;
+				},
+			};
+			const commit = async (/** @type {any[]} */ changes, /** @type {any} */ control) => {
+				const x = await commitShellChanges(changes, ctx, { folders: () => [{ name: 'scratch', root: '/scratch' }], readNow: async (abs) => r.ws.bytes(abs), cancelled: () => control.cancelled() });
+				return { rest: x.rest, notes: x.notes, failed: x.failed.length, refused: x.refused };
+			};
+			// the review applied d/a.txt, could not delete d/b.txt, and so did not hand back the removal of d: one change was made
+			if (how === 'the folder it leaves cannot be made') {
+				r.ws.fail('createDirectory', (k) => k.endsWith('/scratch/m'), new Error('quota'));
+				const res = await agent(r, 'x', { commit });
+				assert.strictEqual(res.code, 1);
+				assert.ok(/PARTLY applied — 1 of 2 file changes/.test(res.stderr), res.stderr);
+				assert.ok(/applied 1 of 4 file changes; stopped at \/scratch\/m: quota\./.test(res.stderr), how + ': ' + res.stderr);
+			} else {
+				r.ws.hang('createDirectory', (k) => k.endsWith('/scratch/m'));
+				const child = r.rt.spawnAgent('x', { cwd: '/scratch', commit });
+				const o = observe(child, 3000);
+				await until(() => r.ws.calls.includes('createDirectory levelcode-scratch:/scratch/m'));
+				child.kill('SIGTERM');
+				await o.closed;
+				assert.ok(/stopped while its file changes were being applied: 1 of 4 were applied\./.test(o.stderr), how + ': ' + o.stderr);
+			}
+			assert.deepStrictEqual([r.ws.list('/scratch'), r.ws.list('/scratch/d')], [['d'], ['b.txt']], how);
+			r.rt.dispose();
+		}
+	});
+
 	await test('a review that THROWS: the status is 1, one honest note, and the shell applies nothing of its own', async () => {
 		const r = createRig();
 		ending(r, { exitCode: 0, changes: [wr('/scratch/a', 'a', null), mkdir('/scratch/d')] });