diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6d7151a0f..5c8eea555 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -10,6 +10,16 @@ Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+### Changed
+
+- When running in watch mode, a persistent service will now restart on each run if it does not have a `files` field in its config. This makes persistent services better match the behavior of standard scripts and ephemeral services.
+
+### Added
+
+- Added a new logger for debugging your Wireit configs. Set `WIREIT_LOGGER=explain` to see detailed information about why each script is run, as well as the normal `simple` logs, without any stdout or stderr of scripts.
+
+- Added more "why" explanations to the `simple` and `metrics` loggers as well, including why a service was restarted, and what file change triggered a new run in watch mode.
+
 ### Fixed
 
 - More reliably handle and report diagnostics for scripts with invalid configurations. Specifically fixed https://github.com/google/wireit/issues/803.
diff --git a/README.md b/README.md
index 53b621ef8..f05e8b1e3 100644
--- a/README.md
+++ b/README.md
@@ -847,14 +847,14 @@ The following syntaxes can be used in the `wireit.<script>.dependencies` array:
 
 The following environment variables affect the behavior of Wireit:
 
-| Variable                | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
-| ----------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `WIREIT_FAILURES`       | [How to handle script failures](#failures-and-errors).<br><br>Options:<br><ul><li>[`no-new`](#failures-and-errors) (default): Allow running scripts to finish, but don't start new ones.</li><li>[`continue`](#continue): Allow running scripts to continue, and start new ones unless any of their dependencies failed.</li><li>[`kill`](#kill): Immediately kill running scripts, and don't start new ones.</li></ul>                                                                                                                                                                                                                                               |
-| `WIREIT_PARALLEL`       | [Maximum number of scripts to run at one time](#parallelism).<br><br>Defaults to 2×logical CPU cores.<br><br>Must be a positive integer or `infinity`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
-| `WIREIT_CACHE`          | [Caching mode](#caching).<br><br>Defaults to `local` unless `CI` is `true`, in which case defaults to `none`.<br><br>Automatically set to `github` by the [`google/wireit@setup-github-actions-caching/v1`](#github-actions-caching) action.<br><br>Options:<ul><li>[`local`](#local-caching): Cache to local disk.</li><li>[`github`](#github-actions-caching): Cache to GitHub Actions.</li><li>`none`: Disable caching.</li></ul>                                                                                                                                                                                                                                  |
-| `CI`                    | Affects the default value of `WIREIT_CACHE`.<br><br>Automatically set to `true` by [GitHub Actions](https://docs.github.com/en/actions/learn-github-actions/environment-variables#default-environment-variables) and most other CI (continuous integration) services.<br><br>Must be exactly `true`. If unset or any other value, interpreted as `false`.                                                                                                                                                                                                                                                                                                             |
-| `WIREIT_MAX_OPEN_FILES` | Limits the number of file descriptors Wireit will have open concurrently. Prevents resource exhaustion when checking large numbers of cached files. Set to a lower number if you hit file descriptor limits.                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
-| `WIREIT_LOGGER`         | How to present progress and results on the command line.<br><br>Options:<br><ul><li>`quiet`: writes a single dynamically updating line summarizing progress. Only passes along stdout and stderr from commands if there's a failure, or if the command is a service. The planned new default, please try it out.</li><li>`simple` (default): A verbose logger that presents clear information about the work that Wireit is doing.</li><li>`metrics`: Like `simple`, but also presents a summary table of results once a command is finished.</li><li>`quiet-ci`: like `quiet` but optimized for non-interactive environments, like GitHub Actions runners.</li></ul> |
+| Variable                | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| ----------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `WIREIT_FAILURES`       | [How to handle script failures](#failures-and-errors).<br><br>Options:<br><ul><li>[`no-new`](#failures-and-errors) (default): Allow running scripts to finish, but don't start new ones.</li><li>[`continue`](#continue): Allow running scripts to continue, and start new ones unless any of their dependencies failed.</li><li>[`kill`](#kill): Immediately kill running scripts, and don't start new ones.</li></ul>                                                                                                                                                                                                                                                                                                                                                                                                                              |
+| `WIREIT_PARALLEL`       | [Maximum number of scripts to run at one time](#parallelism).<br><br>Defaults to 2×logical CPU cores.<br><br>Must be a positive integer or `infinity`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
+| `WIREIT_CACHE`          | [Caching mode](#caching).<br><br>Defaults to `local` unless `CI` is `true`, in which case defaults to `none`.<br><br>Automatically set to `github` by the [`google/wireit@setup-github-actions-caching/v1`](#github-actions-caching) action.<br><br>Options:<ul><li>[`local`](#local-caching): Cache to local disk.</li><li>[`github`](#github-actions-caching): Cache to GitHub Actions.</li><li>`none`: Disable caching.</li></ul>                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| `CI`                    | Affects the default value of `WIREIT_CACHE`.<br><br>Automatically set to `true` by [GitHub Actions](https://docs.github.com/en/actions/learn-github-actions/environment-variables#default-environment-variables) and most other CI (continuous integration) services.<br><br>Must be exactly `true`. If unset or any other value, interpreted as `false`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
+| `WIREIT_MAX_OPEN_FILES` | Limits the number of file descriptors Wireit will have open concurrently. Prevents resource exhaustion when checking large numbers of cached files. Set to a lower number if you hit file descriptor limits.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `WIREIT_LOGGER`         | How to present progress and results on the command line.<br><br>Options:<br><ul><li>`quiet`: writes a single dynamically updating line summarizing progress. Only passes along stdout and stderr from commands if there's a failure, or if the command is a service. The planned new default, please try it out.</li><li>`simple` (default): A verbose logger that presents clear information about the work that Wireit is doing.</li><li>`metrics`: Like `simple`, but also presents a summary table of results once a command is finished.</li><li>`quiet-ci`: like `quiet` but optimized for non-interactive environments, like GitHub Actions runners.</li><li>`explain`: includes detailed information about why each script was run, and does not emit any stdout or stderr from scripts. Useful for debugging your wireit configs.</li></ul> |
 
 ### Glob patterns
 
diff --git a/src/cli-options.ts b/src/cli-options.ts
index f465a89d3..1e67ed125 100644
--- a/src/cli-options.ts
+++ b/src/cli-options.ts
@@ -58,7 +58,7 @@ export interface Options {
   logger: Logger;
 }
 
-export const getOptions = (): Result<Options> => {
+export const getOptions = async (): Promise<Result<Options>> => {
   // This environment variable is set by npm, yarn, and pnpm, and tells us which
   // script is running.
   const scriptName = process.env.npm_lifecycle_event;
@@ -185,7 +185,7 @@ export const getOptions = (): Result<Options> => {
 
   const agent = getNpmUserAgent();
 
-  const loggerResult = ((): Result<Logger> => {
+  const loggerResult = await (async (): Promise<Result<Logger>> => {
     const packageRoot = packageDir ?? process.cwd();
     const str = process.env['WIREIT_LOGGER'];
     if (!str) {
@@ -197,6 +197,10 @@ export const getOptions = (): Result<Options> => {
     if (str === 'quiet-ci') {
       return {ok: true, value: new QuietCiLogger(packageRoot)};
     }
+    if (str === 'explain') {
+      const {ExplainLogger} = await import('./logging/explain-logger.js');
+      return {ok: true, value: new ExplainLogger(packageRoot)};
+    }
     if (str === 'simple') {
       return {ok: true, value: new DefaultLogger(packageRoot)};
     }
@@ -209,7 +213,9 @@ export const getOptions = (): Result<Options> => {
         reason: 'invalid-usage',
         message:
           `Expected the WIREIT_LOGGER env variable to be ` +
-          `"quiet", "simple", or "metrics", got ${JSON.stringify(str)}`,
+          `"quiet", "quiet-ci", "explain", "simple", or "metrics", got ${JSON.stringify(
+            str,
+          )}`,
         script,
         type: 'failure',
       },
diff --git a/src/cli.ts b/src/cli.ts
index 80bdf53f3..2d627a7e5 100644
--- a/src/cli.ts
+++ b/src/cli.ts
@@ -78,7 +78,7 @@ const run = async (options: Options): Promise<Result<void, Failure[]>> => {
       options.agent,
     );
     process.on('SIGINT', () => {
-      watcher.abort();
+      watcher.abort('SIGINT');
     });
     await watcher.watch();
     return {ok: true, value: undefined};
@@ -116,7 +116,7 @@ const run = async (options: Options): Promise<Result<void, Failure[]>> => {
   }
 };
 
-const optionsResult = getOptions();
+const optionsResult = await getOptions();
 if (!optionsResult.ok) {
   // if we can't figure out our options, we can't figure out what logger
   // we should use here, so just use the default logger.
diff --git a/src/event.ts b/src/event.ts
index 8f7aafeef..06e25dad6 100644
--- a/src/event.ts
+++ b/src/event.ts
@@ -11,6 +11,7 @@ import type {
   ScriptReference,
   ScriptReferenceWithCommand,
   PackageReference,
+  ScriptReferenceString,
 } from './config.js';
 
 /**
@@ -354,6 +355,8 @@ export type Info =
   | OutputModified
   | WatchRunStart
   | WatchRunEnd
+  | WatchAborted
+  | WatchedFileTriggeredRun
   | ServiceProcessStarted
   | ServiceReady
   | ServiceStopped
@@ -371,8 +374,82 @@ interface InfoBase<T extends PackageReference = ScriptReference>
  */
 export interface ScriptRunning extends InfoBase<ScriptReferenceWithCommand> {
   detail: 'running';
+  notFreshReason: NotFreshReason;
+  executionRequestedReason: ExecutionRequestedReason;
 }
 
+/**
+ * Answers the question "Why is this script not fresh?"
+ */
+export type NotFreshReason =
+  | {
+      name: 'output manifest outdated';
+      reason: OutputManifestOutdatedReason;
+    }
+  | NeedsToRunReason;
+
+/**
+ * Answers the question "Why does this script need to run?"
+ */
+export type NeedsToRunReason =
+  | {
+      name: 'not-fully-tracked';
+      reason: NotFullyTrackedReason;
+    }
+  | {name: 'no-previous-fingerprint'}
+  | {name: 'fingerprints-differed'; difference: FingerprintDifference};
+
+/**
+ * Answers the question "Why is this script's fingerprint not fully tracked?"
+ */
+export type NotFullyTrackedReason =
+  | {name: 'no files field'}
+  | {name: 'no output field'}
+  | {
+      name: 'dependency not fully tracked';
+      dependency: ScriptReferenceString;
+    };
+
+/**
+ * Answers the question "Why is this script's fingerprint different from the
+ * previous one?"
+ */
+export type FingerprintDifference =
+  | {
+      name: 'environment';
+      field: 'platform' | 'arch' | 'nodeVersion';
+      previous: string;
+      current: string;
+    }
+  | {
+      name: 'config';
+      field: 'command' | 'extraArgs' | 'clean' | 'output' | 'service' | 'env';
+      previous: unknown;
+      current: unknown;
+    }
+  | {name: 'file added'; path: string}
+  | {name: 'file removed'; path: string}
+  | {name: 'file changed'; path: string}
+  | {name: 'dependency removed'; script: ScriptReferenceString}
+  | {name: 'dependency added'; script: ScriptReferenceString}
+  | {name: 'dependency changed'; script: ScriptReferenceString};
+
+/**
+ * One reason why a script might not be fresh is that we can't be sure that
+ * its output files are up to date. This can happen if the output manifest
+ * can't be found, or its output was modified since its last run, or if for
+ * some reason we can't glob its output files.
+ */
+export type OutputManifestOutdatedReason =
+  | 'no previous manifest'
+  | 'output modified'
+  | `can't glob output files`;
+
+/**
+ * Answers the question "what requested this script to run?"
+ */
+export type ExecutionRequestedReason = {path: readonly ScriptReferenceString[]};
+
 /**
  * A script can't run right now because a system-wide lock is being held by
  * another process.
@@ -413,8 +490,13 @@ export interface AnalysisCompleted extends InfoBase {
  */
 export interface WatchRunStart extends InfoBase {
   detail: 'watch-run-start';
+  reason: WatchRunStartReason;
 }
 
+export type WatchRunStartReason =
+  | {name: 'initial'}
+  | {name: 'file-changed'; path: string; operation: FileOperation};
+
 /**
  * A watch mode iteration ended.
  */
@@ -422,6 +504,36 @@ export interface WatchRunEnd extends InfoBase {
   detail: 'watch-run-end';
 }
 
+/**
+ * We're exiting from watch mode.
+ */
+export interface WatchAborted extends InfoBase {
+  detail: 'watch-aborted';
+  reason: WatchAbortedReason;
+}
+
+export type WatchAbortedReason = /** We received a CTRL-C signal. */ 'SIGINT';
+
+/**
+ * A file changed that we're watching, and that triggered the next
+ * watch-run-start.
+ */
+export interface WatchedFileTriggeredRun extends InfoBase {
+  detail: 'watched-file-triggered-run';
+  path: string;
+  operation: FileOperation;
+  /**
+   * true if we noticed the file was changed while a run was active.
+   */
+  runActive: boolean;
+}
+
+export type FileOperation =
+  | 'changed'
+  | 'created'
+  | 'deleted'
+  | 'altered in an unknown way';
+
 /**
  * A service process started running.
  */
@@ -442,8 +554,17 @@ export interface ServiceReady extends InfoBase {
  */
 export interface ServiceStopped extends InfoBase {
   detail: 'service-stopped';
+  reason: ServiceStoppedReason;
+  failure: Failure | undefined;
 }
 
+export type ServiceStoppedReason =
+  | {name: 'the depgraph changed, service is no longer needed'}
+  | {name: 'the run was aborted'}
+  | {name: 'all consumers of the service are done'}
+  | {name: 'restart'; reason: NeedsToRunReason}
+  | {name: 'unknown'};
+
 /**
  * An advisory event about caching.
  */
diff --git a/src/execution/base.ts b/src/execution/base.ts
index 89e14f570..f5e7f086c 100644
--- a/src/execution/base.ts
+++ b/src/execution/base.ts
@@ -10,9 +10,13 @@ import {Deferred} from '../util/deferred.js';
 
 import type {Result} from '../error.js';
 import type {Executor} from '../executor.js';
-import type {Dependency, ScriptConfig} from '../config.js';
+import {
+  scriptReferenceToString,
+  type Dependency,
+  type ScriptConfig,
+} from '../config.js';
 import type {Logger} from '../logging/logger.js';
-import type {Failure} from '../event.js';
+import type {ExecutionRequestedReason, Failure} from '../event.js';
 
 export type ExecutionResult = Result<Fingerprint, Failure[]>;
 
@@ -47,13 +51,22 @@ export abstract class BaseExecution<T extends ScriptConfig> {
   protected readonly _config: T;
   protected readonly _executor: Executor;
   protected readonly _logger: Logger;
+  readonly #executionRequestedReason: ExecutionRequestedReason;
+  #reasonForChildExecution: ExecutionRequestedReason | undefined = undefined;
+
   #fingerprint?: Promise<ExecutionResult>;
 
-  constructor(config: T, executor: Executor, logger: Logger) {
+  constructor(
+    config: T,
+    executor: Executor,
+    logger: Logger,
+    executionRequestedReason: ExecutionRequestedReason,
+  ) {
     executionConstructorHook?.(this);
     this._config = config;
     this._executor = executor;
     this._logger = logger;
+    this.#executionRequestedReason = executionRequestedReason;
   }
 
   /**
@@ -64,6 +77,18 @@ export abstract class BaseExecution<T extends ScriptConfig> {
     return (this.#fingerprint ??= this._execute());
   }
 
+  getReasonForChildExecution(): ExecutionRequestedReason {
+    if (this.#reasonForChildExecution === undefined) {
+      this.#reasonForChildExecution = {
+        path: [
+          ...this.#executionRequestedReason.path,
+          scriptReferenceToString(this._config),
+        ],
+      };
+    }
+    return this.#reasonForChildExecution;
+  }
+
   protected abstract _execute(): Promise<ExecutionResult>;
 
   /**
@@ -79,7 +104,9 @@ export abstract class BaseExecution<T extends ScriptConfig> {
 
     const dependencyResults = await Promise.all(
       this._config.dependencies.map((dependency) => {
-        return this._executor.getExecution(dependency.config).execute();
+        return this._executor
+          .getExecution(dependency.config, this.getReasonForChildExecution())
+          .execute();
       }),
     );
     const results: Array<[Dependency, Fingerprint]> = [];
@@ -124,7 +151,9 @@ export abstract class BaseExecutionWithCommand<
    */
   protected readonly _anyServiceTerminated = Promise.race(
     this._config.services.map(
-      (service) => this._executor.getExecution(service).terminated,
+      (service) =>
+        this._executor.getExecution(service, this.getReasonForChildExecution())
+          .terminated,
     ),
   );
 
@@ -135,7 +164,9 @@ export abstract class BaseExecutionWithCommand<
     if (this._config.services.length > 0) {
       const results = await Promise.all(
         this._config.services.map((service) =>
-          this._executor.getExecution(service).start(),
+          this._executor
+            .getExecution(service, this.getReasonForChildExecution())
+            .start(),
         ),
       );
       const errors: Failure[] = [];
diff --git a/src/execution/no-command.ts b/src/execution/no-command.ts
index cc0fd728c..c2bc9d54f 100644
--- a/src/execution/no-command.ts
+++ b/src/execution/no-command.ts
@@ -19,7 +19,7 @@ export class NoCommandScriptExecution extends BaseExecution<NoCommandScriptConfi
     if (!dependencyFingerprints.ok) {
       return dependencyFingerprints;
     }
-    const fingerprint = await Fingerprint.compute(
+    const result = await Fingerprint.compute(
       this._config,
       dependencyFingerprints.value,
     );
@@ -28,6 +28,6 @@ export class NoCommandScriptExecution extends BaseExecution<NoCommandScriptConfi
       type: 'success',
       reason: 'no-command',
     });
-    return {ok: true, value: fingerprint};
+    return {ok: true, value: result.fingerprint};
   }
 }
diff --git a/src/execution/service.ts b/src/execution/service.ts
index 79099bbab..36e710b4c 100644
--- a/src/execution/service.ts
+++ b/src/execution/service.ts
@@ -5,7 +5,7 @@
  */
 
 import {BaseExecutionWithCommand} from './base.js';
-import {Fingerprint} from '../fingerprint.js';
+import {ComputeFingerprintResult, Fingerprint} from '../fingerprint.js';
 import {Deferred} from '../util/deferred.js';
 import {ScriptChildProcess} from '../script-child-process.js';
 import {LineMonitor} from '../util/line-monitor.js';
@@ -14,7 +14,12 @@ import type {ExecutionResult} from './base.js';
 import type {Dependency, ServiceScriptConfig} from '../config.js';
 import type {Executor} from '../executor.js';
 import type {Logger} from '../logging/logger.js';
-import type {Failure} from '../event.js';
+import type {
+  ExecutionRequestedReason,
+  Failure,
+  NeedsToRunReason,
+  ServiceStoppedReason,
+} from '../event.js';
 import type {Result} from '../error.js';
 
 type ServiceState =
@@ -234,6 +239,7 @@ function unexpectedState(state: ServiceState) {
  */
 export class ServiceScriptExecution extends BaseExecutionWithCommand<ServiceScriptConfig> {
   #state: ServiceState;
+  readonly config: ServiceScriptConfig;
   readonly #terminated = new Deferred<Result<void, Failure>>();
   readonly #isWatchMode: boolean;
 
@@ -246,6 +252,7 @@ export class ServiceScriptExecution extends BaseExecutionWithCommand<ServiceScri
    * its own service dependencies exited unexpectedly.
    */
   readonly terminated = this.#terminated.promise;
+  #stopReason: ServiceStoppedReason = {name: 'unknown'};
 
   constructor(
     config: ServiceScriptConfig,
@@ -254,8 +261,10 @@ export class ServiceScriptExecution extends BaseExecutionWithCommand<ServiceScri
     entireExecutionAborted: Promise<void>,
     adoptee: ServiceScriptExecution | undefined,
     isWatchMode: boolean,
+    executionRequestedReason: ExecutionRequestedReason,
   ) {
-    super(config, executor, logger);
+    super(config, executor, logger, executionRequestedReason);
+    this.config = config;
     this.#isWatchMode = isWatchMode;
     this.#state = {
       id: 'initial',
@@ -264,11 +273,14 @@ export class ServiceScriptExecution extends BaseExecutionWithCommand<ServiceScri
     };
     // Doing this here ensures that we always log when the
     // service stops, no matter how that happens.
-    void this.#terminated.promise.then(() => {
+    void this.#terminated.promise.then((result) => {
+      const failure = result.ok ? undefined : result.error;
       this._logger.log({
         script: this._config,
         type: 'info',
         detail: 'service-stopped',
+        reason: this.#stopReason,
+        failure,
       });
     });
   }
@@ -352,14 +364,21 @@ export class ServiceScriptExecution extends BaseExecutionWithCommand<ServiceScri
         const allConsumersDone = Promise.all(
           this._config.serviceConsumers.map(
             (consumer) =>
-              this._executor.getExecution(consumer).servicesNotNeeded,
+              this._executor.getExecution(
+                consumer,
+                this.getReasonForChildExecution(),
+              ).servicesNotNeeded,
           ),
         );
         const abort = this._config.isPersistent
           ? Promise.all([this.#state.entireExecutionAborted, allConsumersDone])
           : allConsumersDone;
         void abort.then(() => {
-          void this.abort();
+          void this.abort(
+            this._config.isPersistent
+              ? {name: 'the run was aborted'}
+              : {name: 'all consumers of the service are done'},
+          );
         });
 
         this.#state = {
@@ -474,14 +493,41 @@ export class ServiceScriptExecution extends BaseExecutionWithCommand<ServiceScri
     }
   }
 
-  #onFingerprinted(fingerprint: Fingerprint) {
+  #needsToBeRestarted(
+    computeResult: ComputeFingerprintResult,
+    adoptee: ServiceScriptExecution | undefined,
+  ): undefined | NeedsToRunReason {
+    if (computeResult.notFullyTrackedReason !== undefined) {
+      return {
+        name: 'not-fully-tracked',
+        reason: computeResult.notFullyTrackedReason,
+      };
+    }
+    const fingerprint = computeResult.fingerprint;
+    const prevFingerprint = adoptee?.fingerprint;
+    if (prevFingerprint === undefined) {
+      return {name: 'no-previous-fingerprint'};
+    }
+    const difference = fingerprint.difference(prevFingerprint);
+    if (difference === undefined) {
+      return undefined;
+    }
+    return {
+      name: 'fingerprints-differed',
+      difference,
+    };
+  }
+
+  #onFingerprinted(computeResult: ComputeFingerprintResult) {
+    const fingerprint = computeResult.fingerprint;
     switch (this.#state.id) {
       case 'fingerprinting': {
         const adoptee = this.#state.adoptee;
-        if (
-          adoptee?.fingerprint !== undefined &&
-          !adoptee.fingerprint.equal(fingerprint)
-        ) {
+        const needsToRestartReason = this.#needsToBeRestarted(
+          computeResult,
+          adoptee,
+        );
+        if (adoptee !== undefined && needsToRestartReason !== undefined) {
           // There is a previous running version of this service, but the
           // fingerprint changed, so we need to restart it.
           this.#state = {
@@ -489,9 +535,11 @@ export class ServiceScriptExecution extends BaseExecutionWithCommand<ServiceScri
             fingerprint,
             deferredFingerprint: this.#state.deferredFingerprint,
           };
-          void adoptee.abort().then(() => {
-            this.#onAdopteeStopped();
-          });
+          void adoptee
+            .abort({name: 'restart', reason: needsToRestartReason})
+            .then(() => {
+              this.#onAdopteeStopped();
+            });
           return;
         }
         this.#state.deferredFingerprint.resolve({
@@ -978,7 +1026,8 @@ export class ServiceScriptExecution extends BaseExecutionWithCommand<ServiceScri
    * Stop this service if it has started, and return a promise that resolves
    * when it is stopped.
    */
-  abort(): Promise<void> {
+  abort(reason: ServiceStoppedReason): Promise<void> {
+    this.#stopReason = reason;
     switch (this.#state.id) {
       case 'started':
       case 'started-broken': {
diff --git a/src/execution/standard.ts b/src/execution/standard.ts
index 96dc7d4b3..74c0b34c5 100644
--- a/src/execution/standard.ts
+++ b/src/execution/standard.ts
@@ -21,10 +21,20 @@ import type {Result} from '../error.js';
 import type {ExecutionResult} from './base.js';
 import type {Executor} from '../executor.js';
 import type {StandardScriptConfig} from '../config.js';
-import type {FingerprintString} from '../fingerprint.js';
+import type {
+  ComputeFingerprintResult,
+  FingerprintString,
+} from '../fingerprint.js';
 import type {Logger} from '../logging/logger.js';
 import type {Cache, CacheHit} from '../caching/cache.js';
-import type {Failure, StartCancelled} from '../event.js';
+import type {
+  Failure,
+  NotFreshReason,
+  OutputManifestOutdatedReason,
+  ExecutionRequestedReason,
+  StartCancelled,
+  NeedsToRunReason,
+} from '../event.js';
 import type {AbsoluteEntry} from '../util/glob.js';
 import type {FileManifestEntry, FileManifestString} from '../util/manifest.js';
 
@@ -40,6 +50,7 @@ export class StandardScriptExecution extends BaseExecutionWithCommand<StandardSc
   #state: StandardScriptExecutionState = 'before-running';
   readonly #cache?: Cache;
   readonly #workerPool: WorkerPool;
+  readonly #executionRequestedReason: ExecutionRequestedReason;
 
   constructor(
     config: StandardScriptConfig,
@@ -47,10 +58,12 @@ export class StandardScriptExecution extends BaseExecutionWithCommand<StandardSc
     workerPool: WorkerPool,
     cache: Cache | undefined,
     logger: Logger,
+    executionRequestedReason: ExecutionRequestedReason,
   ) {
-    super(config, executor, logger);
+    super(config, executor, logger, executionRequestedReason);
     this.#workerPool = workerPool;
     this.#cache = cache;
+    this.#executionRequestedReason = executionRequestedReason;
   }
 
   #ensureState(state: StandardScriptExecutionState): void {
@@ -79,10 +92,11 @@ export class StandardScriptExecution extends BaseExecutionWithCommand<StandardSc
         // 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 fingerprint = await Fingerprint.compute(
+        const computeResult = await Fingerprint.compute(
           this._config,
           dependencyFingerprints.value,
         );
+        const fingerprint = computeResult.fingerprint;
         if (
           this._executor.failedInPreviousWatchIteration(
             this._config,
@@ -100,18 +114,31 @@ export class StandardScriptExecution extends BaseExecutionWithCommand<StandardSc
             ],
           };
         }
-        if (await this.#fingerprintIsFresh(fingerprint)) {
-          const manifestFresh = await this.#outputManifestIsFresh();
-          if (!manifestFresh.ok) {
-            return {ok: false, error: [manifestFresh.error]};
+
+        let notFreshReason: NotFreshReason;
+        const needsToRunReason = await this.#needsToRun(computeResult);
+        let outputManifestOutdatedReason:
+          | OutputManifestOutdatedReason
+          | undefined;
+        if (needsToRunReason !== undefined) {
+          notFreshReason = needsToRunReason;
+        } else {
+          const manifestResult = await this.#outputManifestOutdatedReason();
+          if (!manifestResult.ok) {
+            return {ok: false, error: [manifestResult.error]};
           }
-          if (manifestFresh.value) {
+          outputManifestOutdatedReason = manifestResult.value;
+          if (outputManifestOutdatedReason === undefined) {
             return this.#handleFresh(fingerprint);
           }
+          notFreshReason = {
+            name: 'output manifest outdated',
+            reason: outputManifestOutdatedReason,
+          };
         }
 
-        // Computing the fingerprint can take some time, and the next operation is
-        // destructive. Another good opportunity to check if we should still
+        // Computing the fingerprint can take some time, and the next operation
+        // is destructive. Another good opportunity to check if we should still
         // start.
         if (this.#shouldNotStart) {
           return {ok: false, error: [this.#startCancelledEvent]};
@@ -127,7 +154,11 @@ export class StandardScriptExecution extends BaseExecutionWithCommand<StandardSc
           return this.#handleCacheHit(cacheHit, fingerprint);
         }
 
-        return this.#handleNeedsRun(fingerprint);
+        return this.#handleNeedsRun(
+          fingerprint,
+          notFreshReason,
+          this.#executionRequestedReason,
+        );
       });
     } finally {
       this._servicesNotNeeded.resolve();
@@ -231,12 +262,28 @@ export class StandardScriptExecution extends BaseExecutionWithCommand<StandardSc
    * Check whether the given fingerprint matches the current one from the
    * `.wireit` directory.
    */
-  async #fingerprintIsFresh(fingerprint: Fingerprint): Promise<boolean> {
-    if (!fingerprint.data.fullyTracked) {
-      return false;
+  async #needsToRun(
+    computeResult: ComputeFingerprintResult,
+  ): Promise<undefined | NeedsToRunReason> {
+    if (computeResult.notFullyTrackedReason !== undefined) {
+      return {
+        name: 'not-fully-tracked',
+        reason: computeResult.notFullyTrackedReason,
+      };
     }
+    const fingerprint = computeResult.fingerprint;
     const prevFingerprint = await this.#readPreviousFingerprint();
-    return prevFingerprint !== undefined && fingerprint.equal(prevFingerprint);
+    if (prevFingerprint === undefined) {
+      return {name: 'no-previous-fingerprint'};
+    }
+    const difference = fingerprint.difference(prevFingerprint);
+    if (difference === undefined) {
+      return undefined;
+    }
+    return {
+      name: 'fingerprints-differed',
+      difference,
+    };
   }
 
   /**
@@ -304,7 +351,11 @@ export class StandardScriptExecution extends BaseExecutionWithCommand<StandardSc
   /**
    * Handle the outcome where the script was stale and we need to run it.
    */
-  async #handleNeedsRun(fingerprint: Fingerprint): Promise<ExecutionResult> {
+  async #handleNeedsRun(
+    fingerprint: Fingerprint,
+    notFreshReason: NotFreshReason,
+    executionRequestedReason: ExecutionRequestedReason,
+  ): Promise<ExecutionResult> {
     // Check if we should clean before we delete the fingerprint file, because
     // we sometimes need to read the previous fingerprint file to determine
     // this.
@@ -358,6 +409,8 @@ export class StandardScriptExecution extends BaseExecutionWithCommand<StandardSc
         script: this._config,
         type: 'info',
         detail: 'running',
+        notFreshReason,
+        executionRequestedReason,
       });
 
       const child = new ScriptChildProcess(
@@ -531,11 +584,14 @@ export class StandardScriptExecution extends BaseExecutionWithCommand<StandardSc
    * Glob the output files for this script and cache them, but throw unless the
    * script has not yet started running or been restored from cache.
    */
-  #globOutputFilesBeforeRunning(): Promise<
+  async #globOutputFilesBeforeRunning(): Promise<
     Result<AbsoluteEntry[] | undefined>
   > {
     this.#ensureState('before-running');
-    return (this.#cachedOutputFilesBeforeRunning ??= this.#globOutputFiles());
+    const result = await (this.#cachedOutputFilesBeforeRunning ??=
+      this.#globOutputFiles());
+    this.#ensureState('before-running');
+    return result;
   }
   #cachedOutputFilesBeforeRunning?: Promise<
     Result<AbsoluteEntry[] | undefined>
@@ -696,21 +752,23 @@ export class StandardScriptExecution extends BaseExecutionWithCommand<StandardSc
    * Check whether the current manifest of output files matches the one from the
    * `.wireit` directory.
    */
-  async #outputManifestIsFresh(): Promise<Result<boolean>> {
+  async #outputManifestOutdatedReason(): Promise<
+    Result<OutputManifestOutdatedReason | undefined>
+  > {
     const oldManifestPromise = this.#readPreviousOutputManifest();
     const outputFilesBeforeRunning = await this.#globOutputFilesBeforeRunning();
     if (!outputFilesBeforeRunning.ok) {
       return outputFilesBeforeRunning;
     }
     if (outputFilesBeforeRunning.value === undefined) {
-      return {ok: true, value: false};
+      return {ok: true, value: `can't glob output files`};
     }
     const newManifest = await this.#computeOutputManifest(
       outputFilesBeforeRunning.value,
     );
     const oldManifest = await oldManifestPromise;
     if (oldManifest === undefined) {
-      return {ok: true, value: false};
+      return {ok: true, value: 'no previous manifest'};
     }
     const equal = newManifest === oldManifest;
     if (!equal) {
@@ -719,8 +777,9 @@ export class StandardScriptExecution extends BaseExecutionWithCommand<StandardSc
         type: 'info',
         detail: 'output-modified',
       });
+      return {ok: true, value: 'output modified'};
     }
-    return {ok: true, value: equal};
+    return {ok: true, value: undefined};
   }
 
   /**
diff --git a/src/executor.ts b/src/executor.ts
index 990b44141..320806e7e 100644
--- a/src/executor.ts
+++ b/src/executor.ts
@@ -23,7 +23,7 @@ import type {
   ServiceScriptConfig,
   StandardScriptConfig,
 } from './config.js';
-import type {Failure} from './event.js';
+import type {ExecutionRequestedReason, Failure} from './event.js';
 import type {Fingerprint} from './fingerprint.js';
 
 type Execution =
@@ -151,7 +151,7 @@ export class Executor {
     this.#stopServices.resolve();
     if (this.#previousIterationServices !== undefined) {
       for (const service of this.#previousIterationServices.values()) {
-        void service.abort();
+        void service.abort({name: 'the run was aborted'});
       }
     }
   }
@@ -178,7 +178,11 @@ export class Executor {
       const abortPromises = [];
       for (const [key, service] of this.#previousIterationServices) {
         if (!currentPersistentServices.has(key)) {
-          abortPromises.push(service.abort());
+          abortPromises.push(
+            service.abort({
+              name: 'the depgraph changed, service is no longer needed',
+            }),
+          );
           this.#previousIterationServices.delete(key);
         }
       }
@@ -186,9 +190,9 @@ export class Executor {
     }
 
     const errors: Failure[] = [];
-    const rootExecutionResult = await this.getExecution(
-      this.#rootConfig,
-    ).execute();
+    const rootExecutionResult = await this.getExecution(this.#rootConfig, {
+      path: [],
+    }).execute();
     if (!rootExecutionResult.ok) {
       errors.push(...rootExecutionResult.error);
     }
@@ -251,12 +255,20 @@ export class Executor {
    * Get the execution instance for a script config, creating one if it doesn't
    * already exist.
    */
-  getExecution<T extends ScriptConfig>(config: T): ConfigToExecution<T> {
+  getExecution<T extends ScriptConfig>(
+    config: T,
+    executionRequestedReason: ExecutionRequestedReason,
+  ): ConfigToExecution<T> {
     const key = scriptReferenceToString(config);
     let execution = this.#executions.get(key);
     if (execution === undefined) {
       if (config.command === undefined) {
-        execution = new NoCommandScriptExecution(config, this, this.#logger);
+        execution = new NoCommandScriptExecution(
+          config,
+          this,
+          this.#logger,
+          executionRequestedReason,
+        );
       } else if (config.service !== undefined) {
         execution = new ServiceScriptExecution(
           config,
@@ -265,6 +277,7 @@ export class Executor {
           this.#stopServices.promise,
           this.#previousIterationServices?.get(key),
           this.#isWatchMode,
+          executionRequestedReason,
         );
         if (config.isPersistent) {
           this.#persistentServices.set(key, execution);
@@ -278,6 +291,7 @@ export class Executor {
           this.#workerPool,
           this.#cache,
           this.#logger,
+          executionRequestedReason,
         );
       }
       this.#executions.set(key, execution);
diff --git a/src/fingerprint.ts b/src/fingerprint.ts
index 53980b8ca..8f6a7a2f0 100644
--- a/src/fingerprint.ts
+++ b/src/fingerprint.ts
@@ -14,6 +14,7 @@ import type {
   ScriptReferenceString,
   Dependency,
 } from './config.js';
+import {FingerprintDifference, NotFullyTrackedReason} from './event.js';
 
 /**
  * All meaningful inputs of a script. Used for determining if a script is fresh,
@@ -113,6 +114,11 @@ type FingerprintSha256HexDigest = string & {
   __FingerprintSha256HexDigestBrand__: never;
 };
 
+export type ComputeFingerprintResult = {
+  fingerprint: Fingerprint;
+  notFullyTrackedReason: NotFullyTrackedReason | undefined;
+};
+
 /**
  * The fingerprint of a script. Converts lazily between string and data object
  * forms.
@@ -131,8 +137,8 @@ export class Fingerprint {
   static async compute(
     script: ScriptConfig,
     dependencyFingerprints: Array<[Dependency, Fingerprint]>,
-  ): Promise<Fingerprint> {
-    let allDependenciesAreFullyTracked = true;
+  ): Promise<ComputeFingerprintResult> {
+    let notFullyTrackedDep: ScriptReferenceString | undefined = undefined;
     const filteredDependencyFingerprints: Array<
       [ScriptReferenceString, FingerprintSha256HexDigest]
     > = [];
@@ -143,7 +149,9 @@ export class Fingerprint {
         continue;
       }
       if (!depFingerprint.data.fullyTracked) {
-        allDependenciesAreFullyTracked = false;
+        if (notFullyTrackedDep === undefined) {
+          notFullyTrackedDep = scriptReferenceToString(dep.config);
+        }
       }
       filteredDependencyFingerprints.push([
         scriptReferenceToString(dep.config),
@@ -186,19 +194,37 @@ export class Fingerprint {
       fileHashes = [];
     }
 
-    const fullyTracked =
+    const notFullyTrackedReason: NotFullyTrackedReason | undefined = (() => {
       // If any any dependency is not fully tracked, then we can't be either,
       // because we can't know if there was an undeclared input that this script
       // depends on.
-      allDependenciesAreFullyTracked &&
+      if (notFullyTrackedDep !== undefined) {
+        return {
+          name: 'dependency not fully tracked',
+          dependency: notFullyTrackedDep,
+        };
+      }
       // A no-command script. Doesn't ever do anything itsef, so always fully
       // tracked.
-      (script.command === undefined ||
-        // A service. Fully tracked if we know its inputs. Can't produce output.
-        (script.service !== undefined && script.files !== undefined) ||
-        // A standard script. Fully tracked if we know both its inputs and
-        // outputs.
-        (script.files !== undefined && script.output !== undefined));
+      if (script.command === undefined) {
+        return undefined;
+      }
+      if (script.files === undefined) {
+        return {name: 'no files field'};
+      }
+      // A service. Always fully tracked. No 'files' means that we
+      // assume that it writes no files. Can't produce output.
+      if (script.service !== undefined) {
+        return undefined;
+      }
+      // A standard script. Fully tracked if we know both its inputs and
+      // outputs.
+      if (script.output === undefined) {
+        return {name: 'no output field'};
+      }
+      return undefined;
+    })();
+    const fullyTracked = notFullyTrackedReason === undefined;
 
     const fingerprint = new Fingerprint();
 
@@ -232,7 +258,7 @@ export class Fingerprint {
       env: script.env,
     };
     fingerprint.#data = data as FingerprintData;
-    return fingerprint;
+    return {fingerprint, notFullyTrackedReason};
   }
 
   #str?: FingerprintString;
@@ -267,4 +293,191 @@ export class Fingerprint {
   equal(other: Fingerprint): boolean {
     return this.string === other.string;
   }
+
+  difference(previous: Fingerprint): FingerprintDifference | undefined {
+    // Do a string comparison first, because it's much faster than
+    // checking field by field;
+    if (this.equal(previous)) {
+      return undefined;
+    }
+
+    // To be sure that we don't miss any differences, as we check each field
+    // we remove its type from this union. If we get to the end and there are
+    // still fields left, then we missed something.
+    type FingerprintFields = Exclude<
+      keyof FingerprintData,
+      '__FingerprintDataBrand__'
+    >;
+    // TODO: we might be able to better explain fingerprint changes if we
+    //     grouped information together. For example, one return value with
+    //     all of the environment fields that changed; one with all config
+    //     fields; one that explains all added, removed, and changed
+    //     dependencies; one with all added, removed, and changed files.
+    type FieldsExcludingPlatform = Exclude<FingerprintFields, 'platform'>;
+    if (this.data.platform !== previous.data.platform) {
+      return {
+        name: 'environment',
+        field: 'platform',
+        current: this.data.platform,
+        previous: previous.data.platform,
+      };
+    }
+    type FieldsExcludingArch = Exclude<FieldsExcludingPlatform, 'arch'>;
+    if (this.data.arch !== previous.data.arch) {
+      return {
+        name: 'environment',
+        field: 'arch',
+        current: this.data.arch,
+        previous: previous.data.arch,
+      };
+    }
+    type FieldsExcludingNodeVersion = Exclude<
+      FieldsExcludingArch,
+      'nodeVersion'
+    >;
+    if (this.data.nodeVersion !== previous.data.nodeVersion) {
+      return {
+        name: 'environment',
+        field: 'nodeVersion',
+        current: this.data.nodeVersion,
+        previous: previous.data.nodeVersion,
+      };
+    }
+    type FieldsExcludingCommand = Exclude<
+      FieldsExcludingNodeVersion,
+      'command'
+    >;
+    if (this.data.command !== previous.data.command) {
+      return {
+        name: 'config',
+        field: 'command',
+        current: this.data.command,
+        previous: previous.data.command,
+      };
+    }
+    type FieldsExcludingExtraArgs = Exclude<
+      FieldsExcludingCommand,
+      'extraArgs'
+    >;
+    if (this.data.extraArgs.join(' ') !== previous.data.extraArgs.join(' ')) {
+      return {
+        name: 'config',
+        field: 'extraArgs',
+        current: this.data.extraArgs,
+        previous: previous.data.extraArgs,
+      };
+    }
+    type FieldsExcludingClean = Exclude<FieldsExcludingExtraArgs, 'clean'>;
+    if (this.data.clean !== previous.data.clean) {
+      return {
+        name: 'config',
+        field: 'clean',
+        current: this.data.clean,
+        previous: previous.data.clean,
+      };
+    }
+    type FieldsExcludingOutput = Exclude<FieldsExcludingClean, 'output'>;
+    if (this.data.output.join(' ') !== previous.data.output.join(' ')) {
+      return {
+        name: 'config',
+        field: 'output',
+        current: this.data.output,
+        previous: previous.data.output,
+      };
+    }
+    type FieldsExcludingService = Exclude<FieldsExcludingOutput, 'service'>;
+    if (
+      this.data.service?.readyWhen.lineMatches !==
+      previous.data.service?.readyWhen.lineMatches
+    ) {
+      return {
+        name: 'config',
+        field: 'service',
+        current: this.data.service,
+        previous: previous.data.service,
+      };
+    }
+    type FieldsExcludingEnv = Exclude<FieldsExcludingService, 'env'>;
+    if (JSON.stringify(this.data.env) !== JSON.stringify(previous.data.env)) {
+      return {
+        name: 'config',
+        field: 'env',
+        current: this.data.env,
+        previous: previous.data.env,
+      };
+    }
+    type FieldsExcludingFiles = Exclude<FieldsExcludingEnv, 'files'>;
+    const thisFiles = new Set(Object.keys(this.data.files));
+    const previousFiles = new Set(Object.keys(previous.data.files));
+    for (const path of thisFiles) {
+      if (!previousFiles.has(path)) {
+        return {name: 'file added', path};
+      }
+    }
+    for (const path of previousFiles) {
+      if (!thisFiles.has(path)) {
+        return {name: 'file removed', path};
+      }
+    }
+    for (const path of thisFiles) {
+      if (this.data.files[path] !== previous.data.files[path]) {
+        return {name: 'file changed', path};
+      }
+    }
+    type FieldsExcludingDependencies = Exclude<
+      FieldsExcludingFiles,
+      'dependencies'
+    >;
+    const thisDependencies = new Set(
+      Object.keys(this.data.dependencies) as ScriptReferenceString[],
+    );
+    const previousDependencies = new Set(
+      Object.keys(previous.data.dependencies) as ScriptReferenceString[],
+    );
+    for (const dependency of thisDependencies) {
+      if (!previousDependencies.has(dependency)) {
+        return {
+          name: 'dependency changed',
+          script: dependency,
+        };
+      }
+    }
+    for (const dependency of previousDependencies) {
+      if (!thisDependencies.has(dependency)) {
+        return {
+          name: 'dependency removed',
+          script: dependency,
+        };
+      }
+    }
+    for (const dependency of thisDependencies) {
+      if (
+        this.data.dependencies[dependency] !==
+        previous.data.dependencies[dependency]
+      ) {
+        return {
+          name: 'dependency changed',
+          script: dependency,
+        };
+      }
+    }
+    type FieldsExcludingFullyTracked = Exclude<
+      FieldsExcludingDependencies,
+      'fullyTracked'
+    >;
+    if (this.data.fullyTracked !== previous.data.fullyTracked) {
+      // This should never happen, because we already checked that all of
+      // the other fields are the same.
+      throw new Error(
+        `Internal error: fingerprints differed only in the 'fullyTracked' field, which should be impossible.\n    current: ${this.string}\n    previous: ${previous.string}`,
+      );
+    }
+    if (false as boolean) {
+      let remainingFields!: FieldsExcludingFullyTracked;
+      remainingFields satisfies never;
+    }
+    throw new Error(
+      `Internal error: fingerprints different but no difference was found.\n    current: ${this.string}\n    previous: ${previous.string}`,
+    );
+  }
 }
diff --git a/src/logging/default-logger.ts b/src/logging/default-logger.ts
index d109e1637..50ad8556d 100644
--- a/src/logging/default-logger.ts
+++ b/src/logging/default-logger.ts
@@ -7,12 +7,22 @@
 import * as pathlib from 'path';
 import {unreachable} from '../util/unreachable.js';
 
-import type {Event} from '../event.js';
+import type {
+  Event,
+  FingerprintDifference,
+  NeedsToRunReason,
+  ServiceStoppedReason,
+} from '../event.js';
 import type {Logger} from './logger.js';
-import type {PackageReference, ScriptReference} from '../config.js';
+import {
+  stringToScriptReference,
+  type PackageReference,
+  type ScriptReference,
+} from '../config.js';
 import {DiagnosticPrinter} from '../error.js';
 import {createRequire} from 'module';
 import {WatchLogger} from './watch-logger.js';
+import {inspect} from 'node:util';
 
 const getWireitVersion = (() => {
   let version: string | undefined;
@@ -32,7 +42,7 @@ const getWireitVersion = (() => {
  * Default {@link Logger} which logs to stdout and stderr.
  */
 export class DefaultLogger implements Logger {
-  readonly #rootPackageDir: string;
+  protected readonly rootPackageDir: string;
   readonly #diagnosticPrinter: DiagnosticPrinter;
 
   /**
@@ -40,13 +50,13 @@ export class DefaultLogger implements Logger {
    * executed belongs to.
    */
   constructor(rootPackage: string) {
-    this.#rootPackageDir = rootPackage;
-    this.#diagnosticPrinter = new DiagnosticPrinter(this.#rootPackageDir);
+    this.rootPackageDir = rootPackage;
+    this.#diagnosticPrinter = new DiagnosticPrinter(this.rootPackageDir);
   }
 
   log(event: Event) {
     const type = event.type;
-    const label = labelForScript(this.#rootPackageDir, event.script);
+    const label = labelForScript(this.rootPackageDir, event.script);
     const prefix = label !== '' ? ` [${label}]` : '';
     switch (type) {
       default: {
@@ -177,7 +187,7 @@ export class DefaultLogger implements Logger {
           case 'dependency-invalid': {
             console.error(
               `❌${prefix} Depended, perhaps indirectly, on ${labelForScript(
-                this.#rootPackageDir,
+                this.rootPackageDir,
                 event.dependency,
               )} which could not be validated. Please file a bug at https://github.com/google/wireit/issues/new, mention this message, that you encountered it in wireit version ${getWireitVersion()}, and give information about your package.json files.`,
             );
@@ -265,6 +275,38 @@ export class DefaultLogger implements Logger {
             console.log(`👀${prefix} Watching for file changes`);
             break;
           }
+          case 'watch-aborted': {
+            switch (event.reason) {
+              case 'SIGINT': {
+                console.log(`🛑${prefix} ctrl-c received, ending watch mode`);
+                break;
+              }
+              default: {
+                const never: never = event;
+                console.log(
+                  `🛑${prefix} Watch aborted for unknown reason: `,
+                  never,
+                );
+              }
+            }
+            break;
+          }
+          case 'watched-file-triggered-run': {
+            if (event.runActive) {
+              console.log(
+                `🔁${prefix} File ${JSON.stringify(event.path)} was ${
+                  event.operation
+                }, queuing up a new run once this one is finished.`,
+              );
+            } else {
+              console.log(
+                `🔁${prefix} File ${JSON.stringify(event.path)} was ${
+                  event.operation
+                }, triggering a new run.`,
+              );
+            }
+            break;
+          }
           case 'cache-info': {
             console.log(`ℹ️${prefix} ${event.message}`);
             break;
@@ -278,7 +320,15 @@ export class DefaultLogger implements Logger {
             break;
           }
           case 'service-stopped': {
-            console.log(`⬇️${prefix} Service stopped`);
+            const reason = this.#explainServiceStopped(event.reason);
+            console.log(`⬇️${prefix} Service stopped because ${reason}`);
+            if (event.failure !== undefined) {
+              // Use console.group to indent
+              console.group();
+              console.log(`Related failure:`);
+              this.log(event.failure);
+              console.groupEnd();
+            }
             break;
           }
           case 'analysis-started':
@@ -290,6 +340,124 @@ export class DefaultLogger implements Logger {
     }
   }
 
+  #explainServiceStopped(reason: ServiceStoppedReason): string {
+    switch (reason.name) {
+      default: {
+        const never: never = reason;
+        throw new Error(`Unknown service stop reason: ${inspect(never)}`);
+      }
+      case 'all consumers of the service are done':
+        return 'all its consumers are done';
+      case 'the depgraph changed, service is no longer needed':
+        return 'the depgraph changed, and it is no longer needed';
+      case 'the run was aborted':
+      case 'unknown':
+        return reason.name;
+      case 'restart': {
+        return this.#explainServiceRestart(reason.reason);
+      }
+    }
+  }
+
+  #explainServiceRestart(reason: NeedsToRunReason): string {
+    switch (reason.name) {
+      default: {
+        const never: never = reason;
+        throw new Error(`Unknown restart reason: ${inspect(never)}`);
+      }
+      case 'not-fully-tracked': {
+        const notFullyTrackedReason = reason.reason;
+        switch (notFullyTrackedReason.name) {
+          default: {
+            const never: never = notFullyTrackedReason;
+            throw new Error(
+              `Unknown not-fully-tracked reason: ${inspect(never)}`,
+            );
+          }
+          case 'dependency not fully tracked': {
+            return `it depends on [${labelForScript(
+              this.rootPackageDir,
+              stringToScriptReference(notFullyTrackedReason.dependency),
+            )}] which must always be run`;
+          }
+          case 'no files field': {
+            return `it has no 'files' field`;
+          }
+          case 'no output field': {
+            throw new Error('Internal error: a service never has output');
+          }
+        }
+      }
+      case 'no-previous-fingerprint': {
+        throw new Error(
+          'Internal error: could not find a previous fingerprint, so we restarted the server?',
+        );
+      }
+      case 'fingerprints-differed': {
+        return this.#explainServiceFingerprintDifference(reason.difference);
+      }
+    }
+  }
+
+  #explainServiceFingerprintDifference(
+    difference: FingerprintDifference,
+  ): string {
+    switch (difference.name) {
+      default: {
+        const never: never = difference;
+        throw new Error(`Unknown not-fully-tracked reason: ${inspect(never)}`);
+      }
+      case 'config': {
+        return `config field ${difference.field} changed from ${inspect(
+          difference.previous,
+        )} to ${inspect(difference.current)}`;
+      }
+      case 'environment': {
+        return `the ${
+          difference.field
+        } of the environment changed from ${inspect(
+          difference.previous,
+        )} to ${inspect(difference.current)}`;
+      }
+      case 'dependency added': {
+        return `a dependency was added: [${labelForScript(
+          this.rootPackageDir,
+          stringToScriptReference(difference.script),
+        )}]`;
+      }
+      case 'dependency removed': {
+        return `a dependency was removed: [${labelForScript(
+          this.rootPackageDir,
+          stringToScriptReference(difference.script),
+        )}]`;
+      }
+      case 'dependency changed': {
+        return `a dependency changed: [${labelForScript(
+          this.rootPackageDir,
+          stringToScriptReference(difference.script),
+        )}]`;
+      }
+      case 'file added': {
+        return `a file was added: ${pathlib.relative(
+          this.rootPackageDir,
+          difference.path,
+        )}`;
+      }
+      case 'file removed': {
+        return `a file was removed: ${pathlib.relative(
+          this.rootPackageDir,
+          difference.path,
+        )}`;
+      }
+      case 'file changed': {
+        return `a file was changed: ${pathlib.relative(
+          this.rootPackageDir,
+          difference.path,
+        )}`;
+      }
+    }
+  }
+
   printMetrics(): void {
     // printMetrics() not used in default-logger.
   }
diff --git a/src/logging/explain-logger.ts b/src/logging/explain-logger.ts
new file mode 100644
index 000000000..242a04769
--- /dev/null
+++ b/src/logging/explain-logger.ts
@@ -0,0 +1,200 @@
+/**
+ * @license
+ * Copyright 2023 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {inspect} from 'node:util';
+import {
+  FingerprintDifference,
+  Event,
+  ExecutionRequestedReason,
+  NotFreshReason,
+  NotFullyTrackedReason,
+  OutputManifestOutdatedReason,
+  ScriptRunning,
+} from '../event.js';
+import {DefaultLogger, labelForScript} from './default-logger.js';
+import {Logger} from './logger.js';
+import {stringToScriptReference} from '../config.js';
+import * as pathlib from 'node:path';
+
+export class ExplainLogger extends DefaultLogger {
+  override log(event: Event): void {
+    if (event.type === 'output') {
+      // When explaining, we care about what wireit is doing, not what
+      // the scripts are doing, so don't log output.
+      return;
+    }
+    super.log(event);
+    if (event.type === 'info' && event.detail === 'running') {
+      this.#logRunning(event);
+    }
+  }
+  #logRunning(event: ScriptRunning) {
+    const notFreshExplanation = this.#explainNotFreshReason(
+      event.notFreshReason,
+    );
+    const executionExplanation = this.#explainExecutionRequestedReason(
+      event.executionRequestedReason,
+    );
+    console.log(`├  You asked it to run because ${executionExplanation}.`);
+    console.log(`└  It can't be skipped because ${notFreshExplanation}.`);
+  }
+
+  #explainExecutionRequestedReason(reason: ExecutionRequestedReason): string {
+    if (reason.path.length === 0) {
+      return 'it was the root script you asked for';
+    }
+    if (reason.path.length === 1) {
+      return `it was a direct dependency of the root script [${labelForScript(
+        this.rootPackageDir,
+        stringToScriptReference(reason.path[0]!),
+      )}] you asked for`;
+    }
+    const path = reason.path
+      .map(
+        (p) =>
+          `[${labelForScript(
+            this.rootPackageDir,
+            stringToScriptReference(p),
+          )}]`,
+      )
+      .join(' -> ');
+    return `it was a dependency along this path: ${path}`;
+  }
+
+  #explainNotFreshReason(reason: NotFreshReason): string {
+    switch (reason.name) {
+      default: {
+        const never: never = reason;
+        throw new Error(`Unknown not-fresh reason: ${inspect(never)}`);
+      }
+      case 'no-previous-fingerprint': {
+        return `this looks like the first run (no previous fingerprint found)`;
+      }
+      case 'fingerprints-differed': {
+        return this.#explainFingerprintsDifferedReason(reason.difference);
+      }
+      case 'not-fully-tracked': {
+        return this.#explainNotFullyTrackedReason(reason.reason);
+      }
+      case 'output manifest outdated': {
+        return this.#explainOutputManifestOutdatedReason(reason.reason);
+      }
+    }
+  }
+
+  #explainFingerprintsDifferedReason(
+    difference: FingerprintDifference,
+  ): string {
+    switch (difference.name) {
+      default: {
+        const never: never = difference;
+        throw new Error(`Unknown not-fully-tracked reason: ${inspect(never)}`);
+      }
+      case 'config': {
+        return `its ${
+          difference.field
+        } field in the package.json file changed from ${inspect(
+          difference.current,
+        )} to ${inspect(difference.previous)}`;
+      }
+      case 'environment': {
+        return `the ${
+          difference.field
+        } aspect of the runtime environment changed from ${inspect(
+          difference.current,
+        )} to ${inspect(difference.previous)}`;
+      }
+      case 'file added': {
+        return `its input file ${pathlib.relative(
+          this.rootPackageDir,
+          difference.path,
+        )} was created`;
+      }
+      case 'file removed': {
+        return `its input file ${pathlib.relative(
+          this.rootPackageDir,
+          difference.path,
+        )} was deleted`;
+      }
+      case 'file changed': {
+        return `its input file ${pathlib.relative(
+          this.rootPackageDir,
+          difference.path,
+        )} was modified`;
+      }
+      case 'dependency added': {
+        return `its dependency on [${labelForScript(
+          this.rootPackageDir,
+          stringToScriptReference(difference.script),
+        )}] was added`;
+      }
+      case 'dependency removed': {
+        return `its dependency on [${labelForScript(
+          this.rootPackageDir,
+          stringToScriptReference(difference.script),
+        )}] was removed`;
+      }
+      case 'dependency changed': {
+        return `its dependency [${labelForScript(
+          this.rootPackageDir,
+          stringToScriptReference(difference.script),
+        )}] was re-run, so we needed to as well`;
+      }
+    }
+  }
+
+  #explainOutputManifestOutdatedReason(
+    reason: OutputManifestOutdatedReason,
+  ): string {
+    switch (reason) {
+      default: {
+        const never: never = reason;
+        throw new Error(
+          `Unknown output manifest outdated reason: ${inspect(never)}`,
+        );
+      }
+      case `can't glob output files`: {
+        return `unable to glob output files`;
+      }
+      case 'no previous manifest': {
+        return `this looks like the first run (no previous output manifest found)`;
+      }
+      case 'output modified': {
+        return `output files were modified since the previous run`;
+      }
+    }
+  }
+
+  #explainNotFullyTrackedReason(reason: NotFullyTrackedReason): string {
+    switch (reason.name) {
+      default: {
+        const never: never = reason;
+        throw new Error(`Unknown not-fully-tracked reason: ${inspect(never)}`);
+      }
+      case 'dependency not fully tracked': {
+        return `depends on ${labelForScript(
+          this.rootPackageDir,
+          stringToScriptReference(reason.dependency),
+        )} which must always be run`;
+      }
+      case 'no files field': {
+        return `it has no "files" field and so it must always be run`;
+      }
+      case 'no output field': {
+        return `it has no "output" field and so it must always be run`;
+      }
+    }
+  }
+
+  override printMetrics(): void {
+    return;
+  }
+
+  override getWatchLogger(): Logger {
+    // Don't use watchLogger, we don't want to clear the terminal.
+    return this;
+  }
+}
diff --git a/src/logging/quiet/run-tracker.ts b/src/logging/quiet/run-tracker.ts
index e39d73b7d..3d2b06a41 100644
--- a/src/logging/quiet/run-tracker.ts
+++ b/src/logging/quiet/run-tracker.ts
@@ -407,6 +407,8 @@ export class QuietRunLogger implements Disposable {
       case 'service-ready':
       case 'watch-run-start':
       case 'watch-run-end':
+      case 'watch-aborted':
+      case 'watched-file-triggered-run':
         return noChange;
       case 'locked': {
         // the script is blocked on starting because something else is
diff --git a/src/logging/watch-logger.ts b/src/logging/watch-logger.ts
index 947f09460..8c0aa97e1 100644
--- a/src/logging/watch-logger.ts
+++ b/src/logging/watch-logger.ts
@@ -66,7 +66,8 @@ export class WatchLogger implements Logger {
       case 'watch-run-start':
       case 'start-cancelled':
       case 'locked':
-      case 'analysis-completed': {
+      case 'analysis-completed':
+      case 'watched-file-triggered-run': {
         return false;
       }
     }
diff --git a/src/test/gc.test.ts b/src/test/gc.test.ts
index 4ad5ff06a..d49ab5020 100644
--- a/src/test/gc.test.ts
+++ b/src/test/gc.test.ts
@@ -74,6 +74,7 @@ async function retryWithGcUntilCallbackDoesNotThrow(
   cb: () => void,
 ): Promise<void> {
   for (const wait of [0, 10, 100, 500, 1000]) {
+    collectGarbage();
     collectGarbage();
     try {
       cb();
@@ -213,7 +214,7 @@ test(
     }
 
     for (const service of previousServices!.values()) {
-      await service.abort();
+      await service.abort({name: 'the run was aborted'});
     }
 
     await retryWithGcUntilCallbackDoesNotThrow(() => {
@@ -251,10 +252,12 @@ test(
           servicePersistent: {
             command: servicePersistent.command,
             service: true,
+            files: [],
           },
           serviceEphemeral: {
             command: serviceEphemeral.command,
             service: true,
+            files: [],
           },
         },
       },
@@ -305,7 +308,7 @@ test(
     }
 
     for (const service of previousServices!.values()) {
-      await service.abort();
+      await service.abort({name: 'the run was aborted'});
     }
 
     await retryWithGcUntilCallbackDoesNotThrow(() => {
diff --git a/src/test/service.test.ts b/src/test/service.test.ts
index 79d0f1c14..73f783a52 100644
--- a/src/test/service.test.ts
+++ b/src/test/service.test.ts
@@ -38,6 +38,13 @@ test.after.each(async (ctx) => {
   }
 });
 
+function testLog(...args: unknown[]) {
+  if (!process.env['SHOW_TEST_OUTPUT']) {
+    return;
+  }
+  console.log(...args);
+}
+
 test(
   'simple consumer and service with stdout',
   timeout(async ({rig}) => {
@@ -649,6 +656,7 @@ for (const failureMode of ['continue', 'no-new']) {
             },
             service: {
               command: service.command,
+              files: [],
               service: true,
             },
             standard: {
@@ -804,6 +812,77 @@ test(
   }),
 );
 
+test(
+  'ephemeral service with files triggers consumer reruns',
+  timeout(async ({rig}) => {
+    // consumer
+    //    |
+    //    v
+    // service
+
+    const consumer = await rig.newCommand();
+    const service = await rig.newCommand();
+    await rig.writeAtomic({
+      'package.json': {
+        scripts: {
+          consumer: 'wireit',
+          service: 'wireit',
+        },
+        wireit: {
+          consumer: {
+            command: consumer.command,
+            dependencies: ['service'],
+            files: ['input'],
+            output: [],
+          },
+          service: {
+            command: service.command,
+            service: true,
+            files: ['serviceInput'],
+          },
+        },
+      },
+    });
+
+    await rig.write('input', '0');
+    await rig.write('serviceInput', '0');
+    const wireit = rig.exec('npm run consumer --watch');
+    await wireit.waitForLog(
+      /50% \[1 \/ 2\] \[2 running\] \[1 service\] consumer/,
+    );
+
+    // Iteration 1
+    {
+      const serviceInv = await service.nextInvocation();
+      const consumerInv = await consumer.nextInvocation();
+      consumerInv.exit(0);
+      await wireit.waitForLog(/✅ Ran 2 scripts and skipped 0/);
+      await consumerInv.closed;
+      await serviceInv.closed;
+    }
+
+    await rig.write('serviceInput', '2');
+    await wireit.waitForLog(
+      /50% \[1 \/ 2\] \[2 running\] \[1 service\] consumer/,
+    );
+
+    // Iteration 2
+    {
+      const serviceInv = await service.nextInvocation();
+      const consumerInv = await consumer.nextInvocation();
+      consumerInv.exit(0);
+      await wireit.waitForLog(/✅ Ran 2 scripts and skipped 0/);
+      await consumerInv.closed;
+      await serviceInv.closed;
+    }
+
+    wireit.kill();
+    await wireit.exit;
+    assert.equal(consumer.numInvocations, 2);
+    assert.equal(service.numInvocations, 2);
+  }),
+);
+
 test(
   'persistent services are preserved across watch iterations',
   timeout(async ({rig}) => {
@@ -833,10 +912,12 @@ test(
           service1: {
             command: service1.command,
             dependencies: ['service2'],
+            files: [],
             service: true,
           },
           service2: {
             command: service2.command,
+            files: [],
             service: true,
           },
           standard: {
@@ -849,9 +930,7 @@ test(
 
     await rig.write('input', '0');
     const wireit = rig.exec('npm run entrypoint --watch');
-    await wireit.waitForLog(
-      /67% \[2 \/ 3\] \[3 running\] \[2 services\] standard/,
-    );
+    await wireit.waitForLog(/67% \[2 \/ 3\] \[3 running\] \[2 services\]/);
 
     // Iteration 1
     {
@@ -1146,6 +1225,7 @@ test(
           service: {
             command: service.command,
             service: true,
+            files: [],
             dependencies: [
               'hard',
               {
@@ -1350,7 +1430,7 @@ test(
   timeout(async ({rig}) => {
     // This test uses standard logger output to ensure that
     // certain operations happen in the right order.
-    rig.env['WIREIT_LOGGER'] = 'simple';
+    rig.env['WIREIT_LOGGER'] = 'explain';
 
     const service = await rig.newCommand();
     const standard = await rig.newCommand();
@@ -1369,11 +1449,13 @@ test(
           standard: {
             command: standard.command,
             files: ['input'],
+            output: [],
           },
         },
       },
     });
 
+    testLog('------------- 1');
     await rig.write('input', '1');
     const wireit = rig.exec('npm run service --watch');
 
@@ -1381,16 +1463,20 @@ test(
     await wireit.waitForLog(/\[standard\] Running/);
     (await standard.nextInvocation()).exit(0);
     await wireit.waitForLog(/\[standard\] Executed successfully/);
-    await service.nextInvocation();
     await wireit.waitForLog(/\[service\] Service ready/);
     await wireit.waitForLog(/\[service\] Watching for file changes/);
+    const serviceInvocation1 = await service.nextInvocation();
     await new Promise((resolve) => setTimeout(resolve, 50));
     assert.equal(service.numInvocations, 1);
     assert.equal(standard.numInvocations, 1);
 
     // Introduce an error. Service keeps running but goes into a temporary
     // "started-broken" state, where it awaits its dependencies being fixed.
+    testLog('------------- 2');
     await rig.write('input', '2');
+    await wireit.waitForLog(
+      /🔁 \[service\] File "input" was changed, triggering a new run./,
+    );
     await wireit.waitForLog(/\[standard\] Running/);
     (await standard.nextInvocation()).exit(1);
     await wireit.waitForLog(/\[standard\] Failed with exit status 1/);
@@ -1401,12 +1487,20 @@ test(
 
     // Fix the error. Service restarts because the fingerprint of its dependency
     // has changed.
+    testLog('------------- 3');
     await rig.write('input', '3');
+    await wireit.waitForLog(
+      /🔁 \[service\] File "input" was changed, triggering a new run./,
+    );
     await wireit.waitForLog(/\[standard\] Running/);
     (await standard.nextInvocation()).exit(0);
     await wireit.waitForLog(/\[standard\] Executed successfully/);
-    await service.nextInvocation();
-    await wireit.waitForLog(/\[service\] Service stopped/);
+    await wireit.waitForLog(
+      /\[service\] Service stopped because it depends on \[standard\] which must always be run/,
+    );
+    await serviceInvocation1.closed;
+    const serviceInvocation2 = await service.nextInvocation();
+    await wireit.waitForLog(/\[service\] Service starting.../);
     await wireit.waitForLog(/\[service\] Service ready/);
     await wireit.waitForLog(/\[service\] Watching for file changes/);
     await new Promise((resolve) => setTimeout(resolve, 50));
@@ -1415,7 +1509,11 @@ test(
 
     // Introduce another error. Again the service keeps running as
     // "started-broken".
+    testLog('------------- 4');
     await rig.write('input', '4');
+    await wireit.waitForLog(
+      /🔁 \[service\] File "input" was changed, triggering a new run./,
+    );
     await wireit.waitForLog(/\[standard\] Running/);
     (await standard.nextInvocation()).exit(1);
     await wireit.waitForLog(/\[standard\] Failed with exit status 1/);
@@ -1427,19 +1525,22 @@ test(
     // Fix the error, this time by reverting. This time the service doesn't
     // restart, because the fingerprint has been restored to what it was before
     // the failure.
+    testLog('------------- 3 again');
     await rig.write('input', '3');
-    await wireit.waitForLog(/\[standard\] Running/);
-    (await standard.nextInvocation()).exit(0);
-    await wireit.waitForLog(/\[standard\] Executed successfully/);
+    await wireit.waitForLog(
+      /🔁 \[service\] File "input" was changed, triggering a new run/,
+    );
+    await wireit.waitForLog(/\[standard\] Restored from cache/);
     await wireit.waitForLog(/\[service\] Watching for file changes/);
     await new Promise((resolve) => setTimeout(resolve, 50));
     assert.equal(service.numInvocations, 2);
-    assert.equal(standard.numInvocations, 5);
+    assert.equal(standard.numInvocations, 4);
 
     wireit.kill();
     await wireit.exit;
+    await serviceInvocation2.closed;
     assert.equal(service.numInvocations, 2);
-    assert.equal(standard.numInvocations, 5);
+    assert.equal(standard.numInvocations, 4);
   }),
 );
 
diff --git a/src/test/util/cli-options-test-binary.ts b/src/test/util/cli-options-test-binary.ts
index c0ea9772a..076ab789a 100644
--- a/src/test/util/cli-options-test-binary.ts
+++ b/src/test/util/cli-options-test-binary.ts
@@ -15,7 +15,7 @@ type SerializableOptions = Omit<Options, 'logger'> & {
   logger: string;
 };
 
-const options = getOptions() as unknown as Result<SerializableOptions>;
+const options = (await getOptions()) as unknown as Result<SerializableOptions>;
 if (options.ok) {
   options.value.logger = options.value.logger.constructor.name;
 }
diff --git a/src/test/util/test-rig.ts b/src/test/util/test-rig.ts
index 32aaef9c6..34f61cda5 100644
--- a/src/test/util/test-rig.ts
+++ b/src/test/util/test-rig.ts
@@ -121,6 +121,7 @@ export class WireitTestRig extends FilesystemTestRig {
       // at the end of the test, and if any are still running then the test
       // has probably failed from timeout. If the process is hung, we'll
       // already see that from the timeout.
+      child.reportStalledLogMatchers();
       child.kill({force: true});
       await child.exit;
     }
@@ -223,6 +224,7 @@ export type {ExecResult};
  * The object returned by {@link WireitTestRig.exec}.
  */
 class ExecResult {
+  readonly #command: string;
   readonly #child: ChildProcessWithoutNullStreams;
   readonly #exited = new Deferred<ExitResult>();
   #running = true;
@@ -236,6 +238,7 @@ class ExecResult {
     cwd: string,
     env: Record<string, string | undefined>,
   ) {
+    this.#command = command;
     // Remove any environment variables that start with "npm_", because those
     // will have been set by the "npm test" or similar command that launched
     // this test itself, and we want a more pristine simulation of running
@@ -347,12 +350,31 @@ class ExecResult {
    */
   waitForLog(matcher: RegExp): Promise<void> {
     const deferred = new Deferred<void>();
-    this.#logMatchers.add({re: matcher, deferred});
+    this.#logMatchers.add({
+      re: matcher,
+      deferred,
+    });
     // In case we've already received the log we're watching for
     this.#checkMatchersAgainstLogs();
     return deferred.promise;
   }
 
+  reportStalledLogMatchers() {
+    if (this.#logMatchers.size === 0) {
+      return;
+    }
+    console.error(`${this.#command} was still waiting to see logs matching:`);
+    for (const {re} of this.#logMatchers) {
+      console.error('  ', re);
+    }
+    console.error(
+      `Unconsumed stdout:\n\`\`\`\n${this.#matcherStdout}\n\`\`\`\n`,
+    );
+    console.error(
+      `Unconsumed stderr:\n\`\`\`\n${this.#matcherStderr}\n\`\`\`\n`,
+    );
+  }
+
   #checkMatchersAgainstLogs() {
     let stdoutLastIndex = -1;
     let stderrLastIndex = -1;
diff --git a/src/watcher.ts b/src/watcher.ts
index bbd61177e..9ee394156 100644
--- a/src/watcher.ts
+++ b/src/watcher.ts
@@ -20,6 +20,11 @@ import {
 
 import type {Agent} from './cli-options.js';
 import type {Fingerprint} from './fingerprint.js';
+import {
+  FileOperation,
+  WatchAbortedReason,
+  WatchRunStartReason,
+} from './event.js';
 
 /**
  * ```
@@ -43,19 +48,19 @@ import type {Fingerprint} from './fingerprint.js';
  * ```
  */
 type WatcherState =
-  | 'initial'
-  | 'watching'
-  | 'debouncing'
-  | 'running'
-  | 'queued'
-  | 'aborted';
+  | {name: 'initial'}
+  | {name: 'watching'}
+  | {name: 'debouncing'; reason: WatchRunStartReason}
+  | {name: 'running'; reason: WatchRunStartReason}
+  | {name: 'queued'; reason: WatchRunStartReason}
+  | {name: 'aborted'; why: WatchAbortedReason};
 
 function unknownState(state: never) {
   return new Error(`Unknown watcher state ${String(state)}`);
 }
 
 function unexpectedState(state: WatcherState) {
-  return new Error(`Unexpected watcher state ${state}`);
+  return new Error(`Unexpected watcher state ${state.name}`);
 }
 
 /**
@@ -89,7 +94,7 @@ const DEBOUNCE_MS = 0;
  */
 export class Watcher {
   /** See {@link WatcherState} */
-  #state: WatcherState = 'initial';
+  #state: WatcherState = {name: 'initial'};
 
   readonly #rootScript: ScriptReference;
   readonly #extraArgs: string[] | undefined;
@@ -144,7 +149,7 @@ export class Watcher {
   }
 
   watch(): Promise<void> {
-    void this.#startRun();
+    void this.#startRun({name: 'initial'});
     return this.#finished.promise;
   }
 
@@ -163,10 +168,10 @@ export class Watcher {
   }
 
   #onDebounced(): void {
-    switch (this.#state) {
+    switch (this.#state.name) {
       case 'debouncing': {
         this.#debounceTimeoutId = undefined;
-        this.#startRun();
+        this.#startRun(this.#state.reason);
         return;
       }
       case 'initial':
@@ -182,15 +187,16 @@ export class Watcher {
     }
   }
 
-  #startRun(): void {
-    switch (this.#state) {
+  #startRun(reason: WatchRunStartReason): void {
+    switch (this.#state.name) {
       case 'initial':
       case 'debouncing': {
-        this.#state = 'running';
+        this.#state = {name: 'running', reason};
         this.#logger.log({
           script: this.#rootScript,
           type: 'info',
           detail: 'watch-run-start',
+          reason,
         });
         if (this.#latestRootScriptConfig === undefined) {
           void this.#analyze();
@@ -221,13 +227,13 @@ export class Watcher {
   }
 
   async #analyze(): Promise<void> {
-    if (this.#state !== 'running') {
+    if (this.#state.name !== 'running') {
       throw unexpectedState(this.#state);
     }
 
     const analyzer = new Analyzer(this.#agent, this.#logger);
     const result = await analyzer.analyze(this.#rootScript, this.#extraArgs);
-    if ((this.#state as WatcherState) === 'aborted') {
+    if ((this.#state as WatcherState).name === 'aborted') {
       return;
     }
 
@@ -264,7 +270,7 @@ export class Watcher {
   }
 
   async #execute(script: ScriptConfig): Promise<void> {
-    if (this.#state !== 'running') {
+    if (this.#state.name !== 'running') {
       throw unexpectedState(this.#state);
     }
     this.#executor = new Executor(
@@ -295,7 +301,7 @@ export class Watcher {
       type: 'info',
       detail: 'watch-run-end',
     });
-    switch (this.#state) {
+    switch (this.#state.name) {
       case 'queued': {
         // Note that the debounce time could actually have already elapsed since
         // the last file change while we were running, but we don't start the
@@ -303,12 +309,12 @@ export class Watcher {
         // interval is also the minimum time between successive runs. This seems
         // fine and probably good, and is simpler than maintaining a separate
         // "queued-debouncing" state.
-        this.#state = 'debouncing';
+        this.#state = {name: 'debouncing', reason: this.#state.reason};
         void this.#startDebounce();
         return;
       }
       case 'running': {
-        this.#state = 'watching';
+        this.#state = {name: 'watching'};
         return;
       }
       case 'aborted': {
@@ -326,15 +332,26 @@ export class Watcher {
     }
   }
 
-  #onConfigFileChanged = (): void => {
+  #onConfigFileChanged = (operation: FileOperation, path: string): void => {
     this.#latestRootScriptConfig = undefined;
-    this.#fileChanged();
+    this.#fileChanged(operation, path);
   };
 
-  #fileChanged = (): void => {
-    switch (this.#state) {
+  #fileChanged = (operation: FileOperation, path: string): void => {
+    switch (this.#state.name) {
       case 'watching': {
-        this.#state = 'debouncing';
+        this.#logger.log({
+          script: this.#rootScript,
+          type: 'info',
+          detail: 'watched-file-triggered-run',
+          path,
+          operation,
+          runActive: false,
+        });
+        this.#state = {
+          name: 'debouncing',
+          reason: {name: 'file-changed', path, operation},
+        };
         void this.#startDebounce();
         return;
       }
@@ -344,7 +361,18 @@ export class Watcher {
         return;
       }
       case 'running': {
-        this.#state = 'queued';
+        this.#logger.log({
+          script: this.#rootScript,
+          type: 'info',
+          detail: 'watched-file-triggered-run',
+          path,
+          operation,
+          runActive: true,
+        });
+        this.#state = {
+          name: 'queued',
+          reason: {name: 'file-changed', path, operation},
+        };
         return;
       }
       case 'queued':
@@ -401,33 +429,39 @@ export class Watcher {
     }
   }
 
-  abort(): void {
+  abort(why: WatchAbortedReason): void {
+    if (this.#state.name === 'aborted') {
+      return;
+    }
     if (this.#executor !== undefined) {
       this.#executor.abort();
       this.#executor = undefined;
     }
-    switch (this.#state) {
+    this.#logger.log({
+      script: this.#rootScript,
+      type: 'info',
+      detail: 'watch-aborted',
+      reason: why,
+    });
+    switch (this.#state.name) {
       case 'debouncing':
       case 'watching': {
-        if (this.#state === 'debouncing') {
+        if (this.#state.name === 'debouncing') {
           this.#cancelDebounce();
         }
-        this.#state = 'aborted';
+        this.#state = {name: 'aborted', why};
         this.#closeAllFileWatchers();
         this.#finished.resolve();
         return;
       }
       case 'running':
       case 'queued': {
-        this.#state = 'aborted';
+        this.#state = {name: 'aborted', why};
         this.#closeAllFileWatchers();
         // Don't resolve #finished immediately so that we will wait for #analyze
         // or #execute to finish.
         return;
       }
-      case 'aborted': {
-        return;
-      }
       case 'initial': {
         throw unexpectedState(this.#state);
       }
@@ -477,7 +511,7 @@ const watchPathsEqual = (
 export const makeWatcher = (
   patterns: string[],
   cwd: string,
-  callback: () => void,
+  callback: (operation: FileOperation, path: string) => void,
   ignoreInitial = true,
 ): FileWatcher => {
   // TODO(aomarks) chokidar doesn't work exactly like fast-glob, so there are
@@ -492,7 +526,31 @@ export const makeWatcher = (
       ignoreInitial,
     },
   );
-  watcher.on('all', callback);
+  watcher.on('all', (kind, path) => {
+    let operation: FileOperation;
+    switch (kind) {
+      case 'add':
+      case 'addDir': {
+        operation = 'created';
+        break;
+      }
+      case 'change': {
+        operation = 'changed';
+        break;
+      }
+      case 'unlink':
+      case 'unlinkDir': {
+        operation = 'deleted';
+        break;
+      }
+      default: {
+        kind satisfies never;
+        operation = 'altered in an unknown way';
+      }
+    }
+
+    callback(operation, path);
+  });
   return {
     patterns,
     watcher,
diff --git a/vscode-extension/package.json b/vscode-extension/package.json
index f4383288b..ed5899244 100644
--- a/vscode-extension/package.json
+++ b/vscode-extension/package.json
@@ -43,6 +43,7 @@
         "..:build"
       ],
       "files": [
+        ".tsbuildinfo",
         "tsconfig.json",
         "src/**/*.ts"
       ],