diff --git a/CHANGELOG.md b/CHANGELOG.md
index 05762e0e5..6c245963f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -13,6 +13,10 @@ Versioning](https://semver.org/spec/v2.0.0.html).
 - Added `WIREIT_CACHE` environment variable, which controls caching behavior.
   Can be `local` or `none` to disable.
 
+- Added `if-file-deleted` option to the `clean` settings. In this mode,
+  `output` files are deleted if any of the input files have been deleted since
+  the last run.
+
 ### Changed
 
 - In watch mode, the terminal is now cleared at the start of each run, making it
diff --git a/README.md b/README.md
index 85c814cc8..06222ad2a 100644
--- a/README.md
+++ b/README.md
@@ -32,6 +32,8 @@
 - [Cleaning output](#cleaning-output)
 - [Watch mode](#watch-mode)
 - [Package locks](#package-locks)
+- [Recipes](#recipes)
+  - [TypeScript](#typescript)
 - [Reference](#reference)
   - [Configuration](#configuration)
   - [Dependency syntax](#dependency-syntax)
@@ -291,13 +293,15 @@ a script. This is helpful for ensuring that every build is clean and free from
 outdated files created in previous runs from source files that have since been
 removed.
 
-To enable output cleaning, configure the output files for each script by
-specifying the `wireit.<script>.output` array (see [caching](#caching) for
-example).
+Cleaning is enabled by default as long as the `output` array is declared (see
+[caching](#caching) for an example). To change this behavior, set the
+`wireit.<script>.clean` property to one of these values:
 
-To disable this behavior, set `<script>.clean` to `false`. You should only
-disable cleaning if you are certain that the script itself already takes care of
-removing outdated files from previous runs.
+| Setting             | Description                                                                                                                                                                                                                                                                                     |
+| ------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `true`              | Clean before every run (the default).                                                                                                                                                                                                                                                           |
+| `"if-file-deleted"` | Clean only if an input file has been deleted since the last run.<br><br>Use this option for tools that have incremental build support, but do not clean up outdated output when a source file has been deleted, such as `tsc --build` (see [TypeScript](#typescript) for more on this example.) |
+| `false`             | Do not clean.<br><br>Only use this option if you are certain that the script command itself already takes care of removing outdated files from previous runs.                                                                                                                                   |
 
 ## Watch mode
 
@@ -357,6 +361,77 @@ If you're sure that a script isn't affected by dependencies at all, you can turn
 off this behavior entirely to improve your cache hit rate by setting
 `wireit.<script>.packageLocks` to `[]`.
 
+## Recipes
+
+This section contains advice about integrating specific build tools with Wireit.
+
+### TypeScript
+
+#### Use incremental build
+
+Set [`"incremental": true`](https://www.typescriptlang.org/tsconfig#incremental)
+in your `tsconfig.json`, and use the
+[`--build`](https://www.typescriptlang.org/docs/handbook/project-references.html#build-mode-for-typescript)
+(or `-b`) flag in your `tsc` command. This enables TypeScript's incremental
+compilation mode, which significantly reduces compile times.
+
+#### Use clean if-file-deleted
+
+The [`"clean": "if-file-deleted"`](#cleaning-output) setting provides the best
+balance between fast and correct output, giving you an incremental build when a
+`.ts` source file is added or modified, and a clean build when a `.ts` source
+file is deleted.
+
+`"clean": true` (the default) is not a good option, because it either eliminates
+the benefits of incremental compilation, or causes your `.tsbuildinfo` to get
+out of sync, depending on whether you include your `.tsbuildinfo` file in the
+`output` array.
+
+`"clean": false` is also not a good option, because it causes stale outputs to
+accumulate. This is because when you delete or rename a `.ts` source file, `tsc`
+itself does not automatically delete the corresponding `.js` file emitted by
+previous compiles.
+
+#### Include .tsbuildinfo in output.
+
+Include your
+[`.tsbuildinfo`](https://www.typescriptlang.org/tsconfig#tsBuildInfoFile) file
+in your `output` array. Otherwise, when Wireit performs a clean build, the
+`.tsbuildinfo` file will get out-of-sync with the output, and `tsc` will wrongly
+skip emit because it believes the output is already up-to-date.
+
+#### Include tsconfig.json in files.
+
+Include your `tsconfig.json` file in your `files` array so that Wireit knows to
+re-run when you change a setting that affects compilation.
+
+#### Use the --pretty flag
+
+By default, `tsc` only shows colorful stylized output when it detects that it is
+attached to an interactive (TTY) terminal. The processes spawned by Wireit do
+not perceive themselves to be attached to an interactive terminal, because of
+the way Wireit captures `stdout` and `stderr` for replays. The
+[`--pretty`](https://www.typescriptlang.org/tsconfig#pretty) flag forces `tsc`
+to emit colorful stylized output even on non-interactive terminals.
+
+#### Example
+
+```json
+{
+  "scripts": {
+    "ts": "wireit"
+  },
+  "wireit": {
+    "ts": {
+      "command": "tsc --build --pretty",
+      "clean": "if-file-deleted",
+      "files": ["src/**/*.ts", "tsconfig.json"],
+      "output": ["lib/**", ".tsbuildinfo"]
+    }
+  }
+}
+```
+
 ## Reference
 
 ### Configuration
@@ -364,14 +439,14 @@ off this behavior entirely to improve your cache hit rate by setting
 The following properties can be set inside `wireit.<script>` objects in
 `package.json` files:
 
-| Property       | Type       | Default                 | Description                                                                                                 |
-| -------------- | ---------- | ----------------------- | ----------------------------------------------------------------------------------------------------------- |
-| `command`      | `string`   | `undefined`             | The shell command to run.                                                                                   |
-| `dependencies` | `string[]` | `undefined`             | [Scripts that must run before this one](#dependencies).                                                     |
-| `files`        | `string[]` | `undefined`             | Input file [glob patterns](#glob-patterns), used to determine the [cache key](#cache-key).                  |
-| `output`       | `string[]` | `undefined`             | Output file [glob patterns](#glob-patterns), used for [caching](#caching) and [cleaning](#cleaning-output). |
-| `clean`        | `boolean`  | `true`                  | [Delete output files before running](#cleaning-output).                                                     |
-| `packageLocks` | `string[]` | `['package-lock.json']` | [Names of package lock files](#package-locks).                                                              |
+| Property       | Type                           | Default                 | Description                                                                                                 |
+| -------------- | ------------------------------ | ----------------------- | ----------------------------------------------------------------------------------------------------------- |
+| `command`      | `string`                       | `undefined`             | The shell command to run.                                                                                   |
+| `dependencies` | `string[]`                     | `undefined`             | [Scripts that must run before this one](#dependencies).                                                     |
+| `files`        | `string[]`                     | `undefined`             | Input file [glob patterns](#glob-patterns), used to determine the [cache key](#cache-key).                  |
+| `output`       | `string[]`                     | `undefined`             | Output file [glob patterns](#glob-patterns), used for [caching](#caching) and [cleaning](#cleaning-output). |
+| `clean`        | `boolean \| "if-file-deleted"` | `true`                  | [Delete output files before running](#cleaning-output).                                                     |
+| `packageLocks` | `string[]`                     | `['package-lock.json']` | [Names of package lock files](#package-locks).                                                              |
 
 ### Dependency syntax
 
diff --git a/src/analyzer.ts b/src/analyzer.ts
index d31a83d01..88a8e5bdd 100644
--- a/src/analyzer.ts
+++ b/src/analyzer.ts
@@ -234,8 +234,18 @@ export class Analyzer {
       }
     }
 
-    if (wireitConfig?.clean !== undefined) {
-      assertBoolean(placeholder, wireitConfig.clean, 'clean');
+    if (
+      wireitConfig?.clean !== undefined &&
+      wireitConfig.clean !== true &&
+      wireitConfig.clean !== false &&
+      wireitConfig.clean !== 'if-file-deleted'
+    ) {
+      throw new WireitError({
+        script: placeholder,
+        type: 'failure',
+        reason: 'invalid-config-syntax',
+        message: `clean must be true, false, or "if-file-deleted"`,
+      });
     }
 
     if (wireitConfig?.packageLocks !== undefined) {
@@ -426,24 +436,6 @@ const assertString = (
   }
 };
 
-/**
- * Throw an error if the given value is not a boolean.
- */
-const assertBoolean = (
-  script: ScriptReference,
-  value: unknown,
-  name: string
-) => {
-  if (typeof value !== 'boolean') {
-    throw new WireitError({
-      type: 'failure',
-      reason: 'invalid-config-syntax',
-      script,
-      message: `${name} is not a boolean`,
-    });
-  }
-};
-
 /**
  * Throw an error if the given value is not an Array.
  */
diff --git a/src/caching/cache.ts b/src/caching/cache.ts
index 254c458a5..620200232 100644
--- a/src/caching/cache.ts
+++ b/src/caching/cache.ts
@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import type {CacheKeyString, ScriptReference} from '../script.js';
+import type {ScriptStateString, ScriptReference} from '../script.js';
 
 /**
  * Saves and restores output files to some cache store (e.g. local disk or
@@ -23,7 +23,7 @@ export interface Cache {
    */
   get(
     script: ScriptReference,
-    cacheKey: CacheKeyString
+    cacheKey: ScriptStateString
   ): Promise<CacheHit | undefined>;
 
   /**
@@ -37,7 +37,7 @@ export interface Cache {
    */
   set(
     script: ScriptReference,
-    cacheKey: CacheKeyString,
+    cacheKey: ScriptStateString,
     relativeFilePaths: string[]
   ): Promise<void>;
 }
diff --git a/src/caching/local-cache.ts b/src/caching/local-cache.ts
index 4a886b092..168b63624 100644
--- a/src/caching/local-cache.ts
+++ b/src/caching/local-cache.ts
@@ -11,7 +11,7 @@ import {getScriptDataDir} from '../util/script-data-dir.js';
 import {optimizeCopies, optimizeMkdirs} from '../util/optimize-fs-ops.js';
 
 import type {Cache, CacheHit} from './cache.js';
-import type {ScriptReference, CacheKeyString} from '../script.js';
+import type {ScriptReference, ScriptStateString} from '../script.js';
 
 /**
  * Caches script output to each package's
@@ -20,7 +20,7 @@ import type {ScriptReference, CacheKeyString} from '../script.js';
 export class LocalCache implements Cache {
   async get(
     script: ScriptReference,
-    cacheKey: CacheKeyString
+    cacheKey: ScriptStateString
   ): Promise<CacheHit | undefined> {
     const cacheDir = this.#getCacheDir(script, cacheKey);
     try {
@@ -36,7 +36,7 @@ export class LocalCache implements Cache {
 
   async set(
     script: ScriptReference,
-    cacheKey: CacheKeyString,
+    cacheKey: ScriptStateString,
     relativeFiles: string[]
   ): Promise<void> {
     // TODO(aomarks) A script's cache directory currently just grows forever.
@@ -86,7 +86,7 @@ export class LocalCache implements Cache {
     );
   }
 
-  #getCacheDir(script: ScriptReference, cacheKey: CacheKeyString): string {
+  #getCacheDir(script: ScriptReference, cacheKey: ScriptStateString): string {
     return pathlib.join(
       getScriptDataDir(script),
       'cache',
diff --git a/src/executor.ts b/src/executor.ts
index 0e1228c4f..e32d7e545 100644
--- a/src/executor.ts
+++ b/src/executor.ts
@@ -15,26 +15,20 @@ import {scriptReferenceToString} from './script.js';
 import {shuffle} from './util/shuffle.js';
 import {WorkerPool} from './util/worker-pool.js';
 import {getScriptDataDir} from './util/script-data-dir.js';
+import {unreachable} from './util/unreachable.js';
 
 import type {
   ScriptConfig,
   ScriptReference,
   ScriptReferenceString,
-  CacheKey,
-  CacheKeyString,
+  ScriptState,
+  ScriptStateString,
   Sha256HexDigest,
 } from './script.js';
 import type {Logger} from './logging/logger.js';
 import type {WriteStream} from 'fs';
 import type {Cache} from './caching/cache.js';
 
-/**
- * Unique symbol to represent a script that isn't safe to be cached, because its
- * input files, or the input files of one of its transitive dependencies, are
- * undefined.
- */
-const UNCACHEABLE = Symbol();
-
 /**
  * The PATH environment variable of this process, minus all of the leading
  * "node_modules/.bin" entries that the incoming "npm run" command already set.
@@ -63,10 +57,7 @@ const IS_WINDOWS = process.platform === 'win32';
  * Executes a script that has been analyzed and validated by the Analyzer.
  */
 export class Executor {
-  readonly #executions = new Map<
-    string,
-    Promise<CacheKey | typeof UNCACHEABLE>
-  >();
+  readonly #executions = new Map<string, Promise<ScriptState>>();
   readonly #logger: Logger;
   readonly #workerPool: WorkerPool;
   readonly #cache?: Cache;
@@ -81,9 +72,9 @@ export class Executor {
     this.#cache = cache;
   }
 
-  async execute(script: ScriptConfig): Promise<CacheKey | typeof UNCACHEABLE> {
-    const cacheKey = scriptReferenceToString(script);
-    let promise = this.#executions.get(cacheKey);
+  async execute(script: ScriptConfig): Promise<ScriptState> {
+    const executionKey = scriptReferenceToString(script);
+    let promise = this.#executions.get(executionKey);
     if (promise === undefined) {
       promise = ScriptExecution.execute(
         script,
@@ -92,7 +83,7 @@ export class Executor {
         this.#cache,
         this.#logger
       );
-      this.#executions.set(cacheKey, promise);
+      this.#executions.set(executionKey, promise);
     }
     return promise;
   }
@@ -108,7 +99,7 @@ class ScriptExecution {
     workerPool: WorkerPool,
     cache: Cache | undefined,
     logger: Logger
-  ): Promise<CacheKey | typeof UNCACHEABLE> {
+  ): Promise<ScriptState> {
     return new ScriptExecution(
       script,
       executor,
@@ -138,35 +129,31 @@ class ScriptExecution {
     this.#logger = logger;
   }
 
-  async #execute(): Promise<CacheKey | typeof UNCACHEABLE> {
-    const dependencyCacheKeys = await this.#executeDependencies();
+  async #execute(): Promise<ScriptState> {
+    const dependencyStates = await this.#executeDependencies();
     // Note we must wait for dependencies to finish before generating the cache
     // key, because a dependency could create or modify an input file to this
     // script, which would affect the key.
-    const cacheKey = await this.#getCacheKey(dependencyCacheKeys);
-    let cacheKeyStr: CacheKeyString | typeof UNCACHEABLE;
-    if (cacheKey !== UNCACHEABLE) {
-      cacheKeyStr = JSON.stringify(cacheKey) as CacheKeyString;
-      const previousCacheKeyStr = await this.#readStateFile();
-      if (
-        previousCacheKeyStr !== undefined &&
-        cacheKeyStr === previousCacheKeyStr
-      ) {
-        // TODO(aomarks) Does not preserve original order of stdout vs stderr
-        // chunks. See https://github.com/google/wireit/issues/74.
-        await Promise.all([
-          this.#replayStdoutIfPresent(),
-          this.#replayStderrIfPresent(),
-        ]);
-        this.#logger.log({
-          script: this.#script,
-          type: 'success',
-          reason: 'fresh',
-        });
-        return cacheKey;
-      }
-    } else {
-      cacheKeyStr = UNCACHEABLE;
+    const state = await this.#computeState(dependencyStates);
+    const stateStr = JSON.stringify(state) as ScriptStateString;
+    const prevStateStr = await this.#readPreviousState();
+    if (
+      state.cacheable &&
+      prevStateStr !== undefined &&
+      prevStateStr === stateStr
+    ) {
+      // TODO(aomarks) Does not preserve original order of stdout vs stderr
+      // chunks. See https://github.com/google/wireit/issues/74.
+      await Promise.all([
+        this.#replayStdoutIfPresent(),
+        this.#replayStderrIfPresent(),
+      ]);
+      this.#logger.log({
+        script: this.#script,
+        type: 'success',
+        reason: 'fresh',
+      });
+      return state;
     }
 
     // It's important that we delete any previous state before running the
@@ -174,22 +161,51 @@ class ScriptExecution {
     // don't want to think that the previous state is still valid.
     await this.#prepareDataDir();
 
-    const cacheHit =
-      cacheKeyStr !== UNCACHEABLE
-        ? await this.#cache?.get(this.#script, cacheKeyStr)
-        : undefined;
-
-    // The "clean" setting controls whether we delete output before execution.
-    //
-    // However, if we are restoring from cache, we should always delete existing
-    // output, regardless of the "clean" setting. The purpose of the "clean"
-    // setting is to allow tools that are smart about cleaning up their own
-    // previous output to work more efficiently, but that only applies when the
-    // tool is able to observe each incremental change to the input files. When
-    // we restore from cache, we are directly replacing the output files, and
-    // not invoking the tool at all, so there is no way for the tool to do any
-    // cleanup.
-    if (this.#script.clean || cacheHit !== undefined) {
+    const cacheHit = state.cacheable
+      ? await this.#cache?.get(this.#script, stateStr)
+      : undefined;
+
+    const shouldClean = (() => {
+      if (cacheHit !== undefined) {
+        // If we are restoring from cache, we should always delete existing
+        // output. The purpose of "clean:false" and "clean:if-file-deleted" is to
+        // allow tools with incremental build (like tsc --build) to work.
+        //
+        // However, this only applies when the tool is able to observe each
+        // incremental change to the input files. When we restore from cache, we
+        // are directly replacing the output files, and not invoking the tool at
+        // all, so there is no way for the tool to do any cleanup.
+        return true;
+      }
+      switch (this.#script.clean) {
+        case true: {
+          return true;
+        }
+        case false: {
+          return false;
+        }
+        case 'if-file-deleted': {
+          if (prevStateStr === undefined) {
+            // If we don't know the previous state, then we can't know whether
+            // any input files were removed. It's safer to err on the side of
+            // cleaning.
+            return true;
+          }
+          return this.#anyInputFilesDeletedSinceLastRun(
+            state,
+            JSON.parse(prevStateStr) as ScriptState
+          );
+        }
+        default: {
+          throw new Error(
+            `Unhandled clean setting: ${
+              unreachable(this.#script.clean) as string
+            }`
+          );
+        }
+      }
+    })();
+    if (shouldClean) {
       await this.#cleanOutput();
     }
 
@@ -212,22 +228,40 @@ class ScriptExecution {
       await this.#executeCommandIfNeeded();
     }
 
-    if (cacheKeyStr !== UNCACHEABLE) {
-      // TODO(aomarks) We don't technically need to wait for these to finish to
-      // return, we only need to wait in the top-level call to execute. The same
-      // will go for saving output to the cache.
-      await this.#writeStateFile(cacheKeyStr);
-      if (cacheHit === undefined) {
-        await this.#saveToCacheIfPossible(cacheKeyStr);
-      }
+    // TODO(aomarks) We don't technically need to wait for these to finish to
+    // return, we only need to wait in the top-level call to execute. The same
+    // will go for saving output to the cache.
+    await this.#writeStateFile(stateStr);
+    if (cacheHit === undefined && state.cacheable) {
+      await this.#saveToCacheIfPossible(stateStr);
     }
 
-    return cacheKey;
+    return state;
+  }
+
+  /**
+   * Compares the current set of input file names to the previous set of input
+   * file names, and returns whether any files have been removed.
+   */
+  #anyInputFilesDeletedSinceLastRun(
+    curState: ScriptState,
+    prevState: ScriptState
+  ): boolean {
+    const curFiles = Object.keys(curState.files);
+    const prevFiles = Object.keys(prevState.files);
+    if (curFiles.length < prevFiles.length) {
+      return true;
+    }
+    const newFilesSet = new Set(curFiles);
+    for (const oldFile of prevFiles) {
+      if (!newFilesSet.has(oldFile)) {
+        return true;
+      }
+    }
+    return false;
   }
 
-  async #executeDependencies(): Promise<
-    Array<[ScriptReference, CacheKey | typeof UNCACHEABLE]>
-  > {
+  async #executeDependencies(): Promise<Array<[ScriptReference, ScriptState]>> {
     // Randomize the order we execute dependencies to make it less likely for a
     // user to inadvertently depend on any specific order, which could indicate
     // a missing edge in the dependency graph.
@@ -240,7 +274,7 @@ class ScriptExecution {
       )
     );
     const errors: unknown[] = [];
-    const results: Array<[ScriptReference, CacheKey | typeof UNCACHEABLE]> = [];
+    const results: Array<[ScriptReference, ScriptState]> = [];
     for (let i = 0; i < dependencyResults.length; i++) {
       const result = dependencyResults[i];
       if (result.status === 'rejected') {
@@ -418,19 +452,13 @@ class ScriptExecution {
   /**
    * Save the current output files to the configured cache if possible.
    */
-  async #saveToCacheIfPossible(
-    cacheKeyStr: CacheKeyString | typeof UNCACHEABLE
-  ): Promise<void> {
-    if (
-      cacheKeyStr === UNCACHEABLE ||
-      this.#cache === undefined ||
-      this.#script.output === undefined
-    ) {
+  async #saveToCacheIfPossible(stateStr: ScriptStateString): Promise<void> {
+    if (this.#cache === undefined || this.#script.output === undefined) {
       return;
     }
     await this.#cache.set(
       this.#script,
-      cacheKeyStr,
+      stateStr,
       await this.#glob(
         [
           ...this.#script.output,
@@ -465,43 +493,21 @@ class ScriptExecution {
   }
 
   /**
-   * Generate the cache key for this script based on its current input files,
-   * and the cache keys of its dependencies.
-   *
-   * Returns the sentinel value {@link UNCACHEABLE} if this script, or any of
-   * this script's transitive dependencies, have undefined input files.
+   * Generate the state object for this script based on its current input files,
+   * and the state of its dependencies.
    */
-  async #getCacheKey(
-    dependencyCacheKeys: Array<[ScriptReference, CacheKey | typeof UNCACHEABLE]>
-  ): Promise<CacheKey | typeof UNCACHEABLE> {
-    if (
-      this.#script.files === undefined &&
-      this.#script.command !== undefined
-    ) {
-      // If files are undefined, then it's never safe for us to be cached,
-      // because we don't know what the inputs are, so we can't know if the
-      // output of this script could change.
-      //
-      // However, if the command is also undefined, then it actually _is_ safe
-      // to be cached, because the script isn't itself going to do anything
-      // anyway. In that case, the cache keys will be purely the cache keys of
-      // the dependencies.
-      return UNCACHEABLE;
-    }
-
-    const filteredDependencyCacheKeys: Array<
-      [ScriptReferenceString, CacheKey]
+  async #computeState(
+    dependencyStates: Array<[ScriptReference, ScriptState]>
+  ): Promise<ScriptState> {
+    let allDependenciesAreCacheable = true;
+    const filteredDependencyStates: Array<
+      [ScriptReferenceString, ScriptState]
     > = [];
-    for (const [dep, depCacheKey] of dependencyCacheKeys) {
-      if (depCacheKey === UNCACHEABLE) {
-        // If one of our dependencies is uncacheable, then we're uncacheable
-        // too, because that dependency could have an effect on our output.
-        return UNCACHEABLE;
+    for (const [dep, depState] of dependencyStates) {
+      if (!depState.cacheable) {
+        allDependenciesAreCacheable = false;
       }
-      filteredDependencyCacheKeys.push([
-        scriptReferenceToString(dep),
-        depCacheKey,
-      ]);
+      filteredDependencyStates.push([scriptReferenceToString(dep), depState]);
     }
 
     let fileHashes: Array<[string, Sha256HexDigest]>;
@@ -531,7 +537,22 @@ class ScriptExecution {
       fileHashes = [];
     }
 
+    const cacheable =
+      // If command is undefined, then it's always safe to be cached, because
+      // the script isn't going to do anything anyway. In these cases, the state
+      // is essentially just the state of the dependencies.
+      this.#script.command === undefined ||
+      // Otherwise, If files are undefined, then it's not safe to be cached,
+      // because we don't know what the inputs are, so we can't know if the
+      // output of this script could change.
+      (this.#script.files !== undefined &&
+        // Similarly, if any of our dependencies are uncacheable, then we're
+        // uncacheable too, because that dependency could also have an effect on
+        // our output.
+        allDependenciesAreCacheable);
+
     return {
+      cacheable,
       command: this.#script.command,
       clean: this.#script.clean,
       files: Object.fromEntries(
@@ -539,7 +560,7 @@ class ScriptExecution {
       ),
       output: this.#script.output ?? [],
       dependencies: Object.fromEntries(
-        filteredDependencyCacheKeys.sort(([aRef], [bRef]) =>
+        filteredDependencyStates.sort(([aRef], [bRef]) =>
           aRef.localeCompare(bRef)
         )
       ),
@@ -577,9 +598,9 @@ class ScriptExecution {
   /**
    * Read this script's ".wireit/<hex-script-name>/state" file.
    */
-  async #readStateFile(): Promise<CacheKeyString | undefined> {
+  async #readPreviousState(): Promise<ScriptStateString | undefined> {
     try {
-      return (await fs.readFile(this.#statePath, 'utf8')) as CacheKeyString;
+      return (await fs.readFile(this.#statePath, 'utf8')) as ScriptStateString;
     } catch (error) {
       if ((error as {code?: string}).code === 'ENOENT') {
         return undefined;
@@ -591,9 +612,9 @@ class ScriptExecution {
   /**
    * Write this script's ".wireit/<hex-script-name>/state" file.
    */
-  async #writeStateFile(cacheKeyStr: CacheKeyString): Promise<void> {
+  async #writeStateFile(stateStr: ScriptStateString): Promise<void> {
     await fs.mkdir(this.#dataDir, {recursive: true});
-    await fs.writeFile(this.#statePath, cacheKeyStr, 'utf8');
+    await fs.writeFile(this.#statePath, stateStr, 'utf8');
   }
 
   /**
diff --git a/src/script.ts b/src/script.ts
index 3c82f0e6f..760568ca8 100644
--- a/src/script.ts
+++ b/src/script.ts
@@ -56,10 +56,14 @@ export interface ScriptConfig extends ScriptReference {
   output: string[] | undefined;
 
   /**
-   * Whether all files matching the output glob patterns should be deleted
-   * before the script executes.
+   * When to clean output:
+   *
+   * - true: Before the script executes, and before restoring from cache.
+   * - false: Before restoring from cache.
+   * - "if-file-deleted": If an input file has been deleted, and before restoring from
+   *   cache.
    */
-  clean: boolean;
+  clean: boolean | 'if-file-deleted';
 }
 
 /**
@@ -94,7 +98,18 @@ export type ScriptReferenceString = string & {
  * All meaningful input state of a script. Used for determining if a script is
  * fresh, and as the key for storing cached output.
  */
-export interface CacheKey {
+export interface ScriptState {
+  /**
+   * Whether the output for this script can be fresh or cached.
+   *
+   * True only if the "files" array was defined for this script, and for all of
+   * this script's transitive dependencies.
+   */
+  cacheable: boolean;
+
+  /**
+   * The shell command from the Wireit config.
+   */
   command: string | undefined;
 
   /**
@@ -104,7 +119,7 @@ export interface CacheKey {
    * could produce different output, so a re-run should be triggered even if
    * nothing else changed.
    */
-  clean: boolean;
+  clean: boolean | 'if-file-deleted';
 
   // Must be sorted.
   files: {[packageDirRelativeFilename: string]: Sha256HexDigest};
@@ -123,19 +138,19 @@ export interface CacheKey {
   output: string[];
 
   // Must be sorted.
-  dependencies: {[dependency: ScriptReferenceString]: CacheKey};
+  dependencies: {[dependency: ScriptReferenceString]: ScriptState};
 }
 
 /**
- * String serialization of a {@link CacheKey}.
+ * String serialization of a {@link ScriptState}.
  */
-export type CacheKeyString = string & {
-  __CacheKeyStringBrand__: never;
+export type ScriptStateString = string & {
+  __ScriptStateStringBrand__: never;
 };
 
 /**
  * SHA256 hash hexadecimal digest of a file's content.
  */
 export type Sha256HexDigest = string & {
-  __Sha256HexDigest__: never;
+  __Sha256HexDigestBrand__: never;
 };
diff --git a/src/test/clean.test.ts b/src/test/clean.test.ts
index 3ad43e26e..6b8da160b 100644
--- a/src/test/clean.test.ts
+++ b/src/test/clean.test.ts
@@ -277,4 +277,149 @@ test(
   })
 );
 
+test(
+  '"if-file-deleted" cleans only when input file deleted',
+  timeout(async ({rig}) => {
+    const cmdA = await rig.newCommand();
+    await rig.write({
+      'package.json': {
+        scripts: {
+          a: 'wireit',
+          b: 'wireit',
+        },
+        wireit: {
+          a: {
+            command: cmdA.command,
+            files: ['input/**'],
+            output: ['output/**'],
+            clean: 'if-file-deleted',
+            // Include a dependency on a script with no input files to cover an
+            // edge case that was broken in an earlier implementation.
+            //
+            // We use the ".wireit/<script>/state" file to find out which input
+            // files were present in the previous run, so that we can compare
+            // them to the current input files. However, in an earlier
+            // implementation we did not save a "state" file for scripts with a
+            // dependency that have no input files (because that makes the
+            // script "uncacheable").
+            dependencies: ['b'],
+          },
+          b: {
+            command: 'true',
+          },
+        },
+      },
+    });
+
+    // Initial run creates output A.
+    {
+      await rig.write({'input/a': 'v0'});
+
+      const exec = rig.exec('npm run a');
+      const inv = await cmdA.nextInvocation();
+
+      // No outputs have been written yet.
+      assert.not(await rig.exists('output/a'));
+      assert.not(await rig.exists('output/b'));
+      assert.not(await rig.exists('output/c'));
+
+      // Write output A.
+      await rig.write({'output/a': 'v0'});
+
+      inv.exit(0);
+      const res = await exec.exit;
+      assert.equal(res.code, 0);
+    }
+
+    // Add new input file. Don't clean. Creates output/b.
+    {
+      await rig.write({'input/b': 'v0'});
+
+      const exec = rig.exec('npm run a');
+      const inv = await cmdA.nextInvocation();
+
+      // Output A should still exist.
+      assert.equal(await rig.read('output/a'), 'v0');
+      assert.not(await rig.exists('output/b'));
+      assert.not(await rig.exists('output/c'));
+
+      // Write outputs A and B.
+      await rig.write({'output/a': 'v1'});
+      await rig.write({'output/b': 'v1'});
+
+      inv.exit(0);
+      const res = await exec.exit;
+      assert.equal(res.code, 0);
+    }
+
+    // Modify input file. Don't clean.
+    {
+      await rig.write({'input/a': 'v1'});
+
+      const exec = rig.exec('npm run a');
+      const inv = await cmdA.nextInvocation();
+
+      // Outputs A and B should still exist.
+      assert.equal(await rig.read('output/a'), 'v1');
+      assert.equal(await rig.read('output/b'), 'v1');
+      assert.not(await rig.exists('output/c'));
+
+      // Write outputs A and B
+      await rig.write({'output/a': 'v2'});
+      await rig.write({'output/b': 'v2'});
+
+      inv.exit(0);
+      const res = await exec.exit;
+      assert.equal(res.code, 0);
+      assert.equal(cmdA.numInvocations, 3);
+    }
+
+    // Delete input file. Clean. (This covers the case where the number of input
+    // files is lower).
+    {
+      await rig.delete('input/a');
+
+      const exec = rig.exec('npm run a');
+      const inv = await cmdA.nextInvocation();
+
+      // Outputs A and B should have been cleaned.
+      assert.not(await rig.exists('output/a'));
+      assert.not(await rig.exists('output/b'));
+      assert.not(await rig.exists('output/c'));
+
+      // Write output B.
+      await rig.write({'output/b': 'v3'});
+
+      inv.exit(0);
+      const res = await exec.exit;
+      assert.equal(res.code, 0);
+    }
+
+    // Delete an input file, and also add an input file. Clean. (This covers the
+    // case where the number of input files are the same, but they are
+    // different.)
+    {
+      await rig.delete('input/b');
+      await rig.write({'input/c': 'v0'});
+
+      const exec = rig.exec('npm run a');
+      const inv = await cmdA.nextInvocation();
+
+      // Output B should have been cleaned.
+      assert.not(await rig.exists('output/a'));
+      assert.not(await rig.exists('output/b'));
+      assert.not(await rig.exists('output/c'));
+
+      // Write output C.
+      await rig.write({'output/c': 'v0'});
+
+      inv.exit(0);
+      const res = await exec.exit;
+      assert.equal(res.code, 0);
+    }
+
+    assert.equal(cmdA.numInvocations, 5);
+  })
+);
+
 test.run();
diff --git a/src/test/errors-analysis.test.ts b/src/test/errors-analysis.test.ts
index 9582b10af..3b5160123 100644
--- a/src/test/errors-analysis.test.ts
+++ b/src/test/errors-analysis.test.ts
@@ -268,7 +268,7 @@ test(
 );
 
 test(
-  'clean is not a boolean',
+  'clean is not a boolean or "if-file-deleted"',
   timeout(async ({rig}) => {
     await rig.write({
       'package.json': {
@@ -289,7 +289,7 @@ test(
     assert.equal(
       done.stderr.trim(),
       `
-❌ [a] Invalid config: clean is not a boolean`.trim()
+❌ [a] Invalid config: clean must be true, false, or "if-file-deleted"`.trim()
     );
   })
 );