@ttsc/unplugin 0.28.5 → 0.29.0

package/src/core/transform.ts

@@ -12,19 +12,32 @@ import {
   type FilesystemPathIdentityContext,
   type FilesystemPathIdentityOperations,
   createFilesystemPathIdentityContext,
+  resolveFilesystemPath,
 } from "ttsc/path-identity";
 import type { TransformResult } from "unplugin";
 
 import type { ResolvedTtscUnpluginOptions } from "./options";
 import {
+  findNearestProjectTsconfig,
+  isIgnoredProjectDirectory,
+} from "./projectDiscovery";
+import {
+  CONFIG_DIR_TEMPLATE_LIST_OPTIONS,
+  CONFIG_DIR_TEMPLATE_SCALAR_OPTIONS,
   type ITtscProjectMembershipPolicy,
   PERMISSIVE_PROJECT_MEMBERSHIP_POLICY,
   absolutizePathsTarget,
   mergeMembershipPolicyOverlay,
   readEffectiveTsconfigPaths,
+  readEffectiveTsconfigTemplateCompilerOptions,
+  readEffectiveTsconfigTemplateFileSpecs,
   readProjectMembershipPolicy,
+  readTsconfigSourceSnapshot,
+  resolveConfigDirTemplatePath,
 } from "./tsconfigPaths";
 
+const TTSC_SEMANTIC_CONFIG_PATH = "TTSC_SEMANTIC_CONFIG_PATH";
+
 /**
  * The normalised transform result type that this module produces.
  *
@@ -284,6 +297,12 @@ const TRANSFORM_FAILED_GENERATION_VALIDATIONS = new WeakMap<
   TtscFailedGenerationValidation
 >();
 
+/** Internal retained clock-probe ownership for published generations. */
+const TRANSFORM_CLOCK_REFERENCE_DIRECTORIES = new WeakMap<
+  TtscCachedProjectTransform,
+  string
+>();
+
 /** Cache promises whose unchanged terminal verdict may be replayed. */
 const TERMINAL_TRANSFORM_GENERATIONS = new WeakMap<
   Promise<TtscCachedProjectTransform>,
@@ -310,6 +329,11 @@ const TRANSFORM_GENERATION_ATTEMPTS = 2;
  * graph-free envelopes retain complete-snapshot validation.
  */
 export interface TtscCachedProjectTransform {
+  /** Predicate-preserving compiler proofs for external candidate spellings. */
+  externalInputObservations?: Record<
+    string,
+    ITtscCompilerTransformation.IInputObservation
+  >;
   /**
    * SHA-256 hash of every input the compiler reported outside the project walk
    * (keyed by filesystem identity), captured at the time of the transform.
@@ -429,6 +453,8 @@ export interface TtscCachedProjectTransform {
   hostInputValidation?: TtscHostInputValidation;
   /** Live notification state for file/directory creation, deletion, and rename. */
   projectMutationTracker?: TtscProjectMutationTracker;
+  /** Whether a generated wrapper and its source config graph stayed coherent. */
+  configStateComplete?: boolean;
   /**
    * Whether the generation-time project walk observed every directory and file
    * it attempted to snapshot. An incomplete walk may never authorize narrow
@@ -697,40 +723,97 @@ function clearTtscTransformCache(cache: TtscTransformCache): void {
  * What the generation already knows about one derived watch input, handed to
  * the adapter so it does not rederive it per input per delivery.
  *
- * Both facts are generation state: the identity is the memoized
- * {@link pathIdentityKey} of the input, and `missing` is the existence the
- * generation recorded and every cache hit revalidates. An adapter that computes
- * them itself pays a `realpath`, a case-sensitivity directory listing, and an
- * `existsSync` for every input of every delivered module, which is O(modules x
- * inputs) for one build (samchon/ttsc#1246).
+ * All facts are generation state: the identity is the memoized
+ * {@link pathIdentityKey} of the input, `missing` preserves the original public
+ * existence contract, and `unavailable` distinguishes a failed file predicate
+ * from ordinary absence. An adapter that computes them itself pays a
+ * `realpath`, a case-sensitivity directory listing, and an `existsSync` for
+ * every input of every delivered module, which is O(modules x inputs) for one
+ * build (samchon/ttsc#1246).
  */
 export interface TtscWatchInputEvidence {
   /** Memoized filesystem identity of the input. */
   identity: string;
-  /** Whether the generation recorded this input as absent. */
+  /** Whether the generation recorded this input as unavailable as a file. */
   missing: boolean;
+  /** The generation state Metro can compare with its main-process baseline. */
+  state?: TtscWatchInputState;
+  /** Which unavailable predicate must become true before invalidation. */
+  unavailable?: "missing" | "not-file";
+}
+
+/** Exact generation state behind one derived watch input. */
+export type TtscWatchInputState =
+  | {
+      /** A project-walk or dependency-only input read as ordinary host bytes. */
+      codec: "host";
+      hash: string;
+    }
+  | {
+      /** A realized compiler-graph input, including its physical target. */
+      codec: "graph";
+      hash: string;
+      realpath: string | null;
+    }
+  | {
+      /** The exact compiler predicates observed for a resolver input. */
+      codec: "predicates";
+      observation: ITtscCompilerTransformation.IInputObservation;
+    };
+
+/** Main-process file predicate used only by project discovery. */
+export interface TtscWatchInputFileBaseline {
+  fileExists: boolean;
+  identity: string;
+}
+
+/** Main-process state broad enough to compare every watch-input codec. */
+export interface TtscWatchInputBaseline extends TtscWatchInputFileBaseline {
+  directoryExists: boolean;
+  graphHash: string;
+  graphReadHash: string | null;
+  hostHash: string;
+  realpath: { ok: false; path?: never } | { ok: true; path: string };
+  stat: "directory" | "file" | "missing";
+}
+
+/** Baseline shape stored for either a discovery predicate or a full input. */
+export type TtscWatchInputKeyBaseline =
+  | TtscWatchInputFileBaseline
+  | TtscWatchInputBaseline;
+
+/** One derived input and its optional generation proof. */
+export interface TtscWatchInput {
+  evidence?: TtscWatchInputEvidence;
+  file: string;
 }
 
 /**
  * Hooks the bundler adapter passes into {@link transformTtsc} so transform
- * side-channels (plugin-reported dependencies and host resolution candidates)
- * reach the bundler without leaking extra fields on the returned
- * `TransformResult`.
+ * side-channels (plugin-reported dependencies and host resolver inputs) reach
+ * the bundler without leaking extra fields on the returned `TransformResult`.
  */
 export interface TtscTransformHooks {
   /**
    * Invoked once per absolute watch-input path derived for the transformed file
    * `F`: the plugin-reported `dependencies[F]` list unioned with the host-owned
    * reference graph's contribution — the reachability closure of `graph.edges`
-   * from `F`, the `graph.globals` files, the `graph.configs` chain, and missing
-   * higher-priority `graph.candidates` — or, for a file the envelope declared
-   * `dependenciesComplete`, only `dependencies[F]`, `graph.candidates`, and the
-   * universal `graph.configs` chain. Adapters forward this to the bundler's
+   * from `F`, the `graph.globals` files, the `graph.configs` chain, importer
+   * `graph.candidates`, and universal `graph.resolutionInputs`. For a file the
+   * envelope declared `dependenciesComplete`, only `dependencies[F]`,
+   * `graph.candidates`, `graph.resolutionInputs`, and the universal
+   * `graph.configs` chain remain. Adapters forward this to the bundler's
    * `addWatchFile` so type-only inputs participate in watch-mode and
    * persistent-cache invalidation. See {@link selectWatchInputs} for the exact
    * derivation.
    */
   addWatchFile?: (file: string, evidence?: TtscWatchInputEvidence) => void;
+  /**
+   * Batched form of {@link addWatchFile}. When supplied, the transform calls it
+   * once per delivered module and does not call `addWatchFile` for that
+   * module.
+   */
+  addWatchFiles?: (inputs: readonly TtscWatchInput[]) => void;
   /**
    * Invoked when the plugin declared the transformed file volatile (the
    * envelope's `volatile` list): its output depends on non-file inputs that no
@@ -756,8 +839,7 @@ export interface TtscTransformHooks {
  * @param id - Bundler module id (may carry a query string or virtual prefix).
  * @param source - Current file content supplied by the bundler.
  * @param options - Resolved plugin options.
- * @param aliases - Raw bundler alias configuration (Vite array or webpack
- *   object).
+ * @param aliases - Raw Vite alias configuration (object or array).
  * @param cache - Optional project cache. Callers with a real `buildStart`
  *   boundary declare it through {@link beginTtscTransformBuild}; other hosts
  *   retain persistent validation.
@@ -868,9 +950,11 @@ export async function transformTtsc(
           }
           // The compile is fine and simply has nothing for this module, so the
           // module goes back to the host untransformed rather than failing the
-          // build (samchon/ttsc#1308). It still counts as delivered in this
-          // pass, and there is nothing to watch for a file with no output.
+          // build (samchon/ttsc#1308). Its project config and selection inputs
+          // still decide whether a later generation will contain this module,
+          // so hosts must receive the same universal watch-input batch.
           reportMissingProgramOutput(cached, error, epoch);
+          notifyWatchInputs(hooks, cached, file);
           markCachedSourceServed(cached, file);
           return undefined;
         }
@@ -926,6 +1010,7 @@ export async function transformTtsc(
         throw error;
       }
       reportMissingProgramOutput(cached, error, epoch);
+      notifyWatchInputs(hooks, cached, file);
       markCachedSourceServed(cached, file);
       return undefined;
     }
@@ -1129,7 +1214,7 @@ function evictGeneration(
   }
 }
 
-/** Close one generation's directory watchers exactly once. */
+/** Release one generation's watchers and retained clock probe exactly once. */
 function disposeCachedTransform(cached: TtscCachedProjectTransform): void {
   const trackers = [
     cached.projectMutationTracker,
@@ -1139,7 +1224,21 @@ function disposeCachedTransform(cached: TtscCachedProjectTransform): void {
   cached.projectMutationTracker = undefined;
   cached.hostInputMutationTracker = undefined;
   cached.candidateMutationTracker = undefined;
-  for (const tracker of trackers) tracker?.close();
+  const clockReferenceDirectory =
+    TRANSFORM_CLOCK_REFERENCE_DIRECTORIES.get(cached);
+  TRANSFORM_CLOCK_REFERENCE_DIRECTORIES.delete(cached);
+  for (const tracker of trackers) {
+    try {
+      tracker?.close();
+    } catch {
+      // Disposal is scheduled behind fulfilled generation Promises, so it has
+      // no caller that can recover from a close failure. Keep releasing every
+      // independent resource and leave no rejected cleanup Promise behind.
+    }
+  }
+  if (clockReferenceDirectory !== undefined) {
+    disposeFilesystemClockReference(clockReferenceDirectory);
+  }
 }
 
 /**
@@ -1198,7 +1297,7 @@ interface TtscEnvelopeDerivation {
    * mirroring the historical scan). `undefined` until the first key miss.
    */
   dependencyIndex?: Map<string, unknown>;
-  /** Per-file memo of the final derived watch-input list. */
+  /** Per lexical delivered-module spelling memo of its final watch-input list. */
   readonly watchInputs: Map<string, string[]>;
   /**
    * Lazily built project-walk keys of the envelope's declared inputs, and
@@ -1255,38 +1354,39 @@ interface TtscEnvelopeGraphIndexes {
   readonly edges: Map<string, string[]>;
   /** Identity of each direct-edge source -> its absolute spelling. */
   readonly spellings: Map<string, string>;
-  /** Resolution-candidate entries in envelope order, sources pre-identified. */
+  /** Importer-owned resolver-input entries, sources pre-identified. */
   readonly candidates: { source: string; files: string[] }[];
   /** Resolved absolute `graph.globals` and `graph.configs` members. */
   readonly globals: string[];
   readonly configs: string[];
-  /** Every realized/candidate graph path, keyed by filesystem identity. */
-  readonly members: Set<string>;
+  /** Resolver inputs whose state affects every source file. */
+  readonly resolutionInputs: string[];
+  /** Every realized or resolver-input path, keyed by lexical spelling. */
+  readonly memberSpellings: Set<string>;
   /**
-   * Members the envelope reported only under `graph.candidates`, keyed by
-   * filesystem identity.
-   *
-   * A superseding candidate is by construction a path the compiler did not
-   * select, and usually one it never read at all: resolution stopped at the
-   * target that won, and the host enumerates the higher-priority spellings so
-   * that one appearing later can invalidate the generation. Such a path has no
-   * compile-time read to prove, so it carries the evidence a plugin-declared
-   * dependency path carries (the state recorded when the envelope was produced)
-   * instead of a compiler proof it can never have.
-   *
-   * A candidate that is also a realized input (an edge endpoint, a global, or a
-   * config) is absent from this set and keeps the realized standard.
+   * Predicate-only resolver inputs, keyed by absolute lexical spelling. These
+   * are exact compiler calls but need not carry file content, for example a
+   * failed file predicate or automatic type-root directory enumeration. A path
+   * that is also a realized edge, global, config, or source keeps the stronger
+   * realized-file standard.
    */
   readonly speculative: Set<string>;
-  /** Compiler-time proof for graph members, keyed by filesystem identity. */
+  /** Compiler-time legacy proof keyed by absolute lexical spelling. */
   readonly inputProofs: Map<
     string,
     { hash: string | null; path: string; realpath: string | null }
   >;
-  /** Native compiler-observation failure for an unproven member identity. */
+  /** Native compiler-observation failure keyed by absolute lexical spelling. */
   readonly inputProofFailures: Map<string, string>;
-  /** Aliased graph proof keys that reported contradictory generation states. */
+  /** Graph proof spellings that reported contradictory generation states. */
   readonly inputProofConflicts: Set<string>;
+  /** Predicate-preserving proofs keyed by absolute lexical spelling. */
+  readonly inputObservations: Map<
+    string,
+    ITtscCompilerTransformation.IInputObservation
+  >;
+  /** Absolute spellings whose predicate proof is malformed or contradictory. */
+  readonly inputObservationConflicts: Set<string>;
 }
 
 /**
@@ -1334,17 +1434,22 @@ function envelopeGraphIndexes(
   if (state.graph !== undefined) {
     return state.graph;
   }
+  const platform = resultFilesystem(props.result).platform ?? process.platform;
+  const pathApi = platform === "win32" ? path.win32 : path.posix;
   const built: TtscEnvelopeGraphIndexes = {
     edges: new Map(),
     spellings: new Map(),
     candidates: [],
     globals: [],
     configs: [],
-    members: new Set(),
+    resolutionInputs: [],
+    memberSpellings: new Set(),
     speculative: new Set(),
     inputProofs: new Map(),
     inputProofFailures: new Map(),
     inputProofConflicts: new Set(),
+    inputObservations: new Map(),
+    inputObservationConflicts: new Set(),
   };
   const graph =
     props.result.type === "exception" ? undefined : props.result.graph;
@@ -1355,7 +1460,7 @@ function envelopeGraphIndexes(
       }
       const absolute = path.resolve(props.projectRoot, source);
       const identity = derivationIdentity(state, absolute);
-      built.members.add(identity);
+      built.memberSpellings.add(absolute);
       built.spellings.set(identity, absolute);
       const entries = built.edges.get(identity) ?? [];
       entries.push(
@@ -1367,7 +1472,7 @@ function envelopeGraphIndexes(
           .map((target) => {
             const absoluteTarget = path.resolve(props.projectRoot, target);
             const targetIdentity = derivationIdentity(state, absoluteTarget);
-            built.members.add(targetIdentity);
+            built.memberSpellings.add(absoluteTarget);
             if (!built.spellings.has(targetIdentity)) {
               built.spellings.set(targetIdentity, absoluteTarget);
             }
@@ -1380,7 +1485,7 @@ function envelopeGraphIndexes(
     built.configs.push(...selectListedFiles(props.projectRoot, graph.configs));
     for (const input of [...built.globals, ...built.configs]) {
       const identity = derivationIdentity(state, input);
-      built.members.add(identity);
+      built.memberSpellings.add(path.resolve(input));
       if (!built.spellings.has(identity)) built.spellings.set(identity, input);
     }
     const candidateEntries = Object.entries(graph.candidates ?? {}).filter(
@@ -1393,12 +1498,22 @@ function envelopeGraphIndexes(
     for (const [source] of candidateEntries) {
       const absoluteSource = path.resolve(props.projectRoot, source);
       const identity = derivationIdentity(state, absoluteSource);
-      built.members.add(identity);
+      built.memberSpellings.add(absoluteSource);
       if (!built.spellings.has(identity)) {
         built.spellings.set(identity, absoluteSource);
       }
     }
-    const realized = new Set(built.members);
+    const realized = new Set(built.memberSpellings);
+    built.resolutionInputs.push(
+      ...selectListedFiles(props.projectRoot, graph.resolutionInputs),
+    );
+    for (const input of built.resolutionInputs) {
+      const spelling = path.resolve(input);
+      const identity = derivationIdentity(state, input);
+      if (!realized.has(spelling)) built.speculative.add(spelling);
+      built.memberSpellings.add(spelling);
+      if (!built.spellings.has(identity)) built.spellings.set(identity, input);
+    }
     for (const [source, candidates] of candidateEntries) {
       built.candidates.push({
         source: derivationIdentity(
@@ -1409,33 +1524,64 @@ function envelopeGraphIndexes(
       });
       for (const candidate of candidates) {
         if (typeof candidate !== "string" || candidate.length === 0) continue;
-        const identity = derivationIdentity(
-          state,
-          path.resolve(props.projectRoot, candidate),
-        );
+        const absoluteCandidate = path.resolve(props.projectRoot, candidate);
+        const identity = derivationIdentity(state, absoluteCandidate);
         // Edges, globals, configs, and every candidate source are folded in
         // above, so a path absent from that set is one the envelope reported
         // only as a candidate.
-        if (!realized.has(identity)) built.speculative.add(identity);
-        built.members.add(identity);
+        if (!realized.has(absoluteCandidate)) {
+          built.speculative.add(absoluteCandidate);
+        }
+        built.memberSpellings.add(absoluteCandidate);
         if (!built.spellings.has(identity)) {
-          built.spellings.set(
-            identity,
-            path.resolve(props.projectRoot, candidate),
-          );
+          built.spellings.set(identity, absoluteCandidate);
         }
       }
     }
-    const transformSources = new Set<string>();
+    const transformSourceSpellings = new Set<string>();
     if (props.result.type === "success") {
       for (const output of Object.keys(props.result.typescript)) {
         if (!isDeclarationFile(output)) {
-          transformSources.add(
-            derivationIdentity(state, path.resolve(props.projectRoot, output)),
-          );
+          const absoluteOutput = path.resolve(props.projectRoot, output);
+          transformSourceSpellings.add(absoluteOutput);
         }
       }
     }
+    for (const [input, reported] of Object.entries(
+      graph.inputObservations ?? {},
+    )) {
+      if (input.length === 0) continue;
+      const absolute = path.resolve(props.projectRoot, input);
+      const spelling = path.resolve(absolute);
+      if (
+        !built.memberSpellings.has(spelling) &&
+        !transformSourceSpellings.has(spelling)
+      ) {
+        continue;
+      }
+      const normalized = normalizeGraphInputObservation(reported, platform);
+      if (normalized === undefined) {
+        built.inputObservationConflicts.add(spelling);
+        if (!built.inputProofFailures.has(spelling)) {
+          built.inputProofFailures.set(spelling, "malformed-observation");
+        }
+        continue;
+      }
+      const previous = built.inputObservations.get(spelling);
+      const merged =
+        previous === undefined
+          ? normalized
+          : mergeGraphInputObservations(previous, normalized);
+      if (merged === undefined) {
+        built.inputObservations.delete(spelling);
+        built.inputObservationConflicts.add(spelling);
+        if (!built.inputProofFailures.has(spelling)) {
+          built.inputProofFailures.set(spelling, "conflicting-observation");
+        }
+      } else if (!built.inputObservationConflicts.has(spelling)) {
+        built.inputObservations.set(spelling, merged);
+      }
+    }
     for (const [input, hash] of Object.entries(graph.inputHashes ?? {})) {
       if (
         hash !== null &&
@@ -1453,22 +1599,27 @@ function envelopeGraphIndexes(
       if (
         reportedRealpath !== null &&
         (typeof reportedRealpath !== "string" ||
-          !path.isAbsolute(reportedRealpath))
+          !pathApi.isAbsolute(reportedRealpath))
       ) {
         continue;
       }
       const absolute = path.resolve(props.projectRoot, input);
-      const identity = derivationIdentity(state, absolute);
-      if (!built.members.has(identity) && !transformSources.has(identity)) {
+      const spelling = path.resolve(absolute);
+      if (
+        !built.memberSpellings.has(spelling) &&
+        !transformSourceSpellings.has(spelling)
+      ) {
         continue;
       }
       const proof = {
         hash,
         path: absolute,
         realpath:
-          reportedRealpath === null ? null : path.resolve(reportedRealpath),
+          reportedRealpath === null
+            ? null
+            : resolveFilesystemPath(reportedRealpath, platform),
       };
-      const previous = built.inputProofs.get(identity);
+      const previous = built.inputProofs.get(spelling);
       if (
         previous !== undefined &&
         (previous.hash !== proof.hash ||
@@ -1478,10 +1629,10 @@ function envelopeGraphIndexes(
             state.identityContext,
           ))
       ) {
-        built.inputProofs.delete(identity);
-        built.inputProofConflicts.add(identity);
-      } else if (!built.inputProofConflicts.has(identity)) {
-        built.inputProofs.set(identity, proof);
+        built.inputProofs.delete(spelling);
+        built.inputProofConflicts.add(spelling);
+      } else if (!built.inputProofConflicts.has(spelling)) {
+        built.inputProofs.set(spelling, proof);
       }
     }
     for (const [input, reason] of Object.entries(
@@ -1491,16 +1642,35 @@ function envelopeGraphIndexes(
         continue;
       }
       const absolute = path.resolve(props.projectRoot, input);
-      const identity = derivationIdentity(state, absolute);
-      if (!built.members.has(identity) && !transformSources.has(identity)) {
+      const spelling = path.resolve(absolute);
+      if (
+        !built.memberSpellings.has(spelling) &&
+        !transformSourceSpellings.has(spelling)
+      ) {
+        continue;
+      }
+      const observation = built.inputObservations.get(spelling);
+      const legacyProjection =
+        observation === undefined
+          ? undefined
+          : legacyProjectionOfGraphInputObservation(observation);
+      if (
+        built.speculative.has(spelling) &&
+        !built.inputProofs.has(spelling) &&
+        legacyProjection?.failure === reason
+      ) {
         continue;
       }
-      if (built.inputProofs.has(identity)) {
-        built.inputProofs.delete(identity);
-        built.inputProofConflicts.add(identity);
+      if (built.inputObservations.has(spelling)) {
+        built.inputObservations.delete(spelling);
+        built.inputObservationConflicts.add(spelling);
       }
-      if (!built.inputProofFailures.has(identity)) {
-        built.inputProofFailures.set(identity, reason);
+      if (built.inputProofs.has(spelling)) {
+        built.inputProofs.delete(spelling);
+        built.inputProofConflicts.add(spelling);
+      }
+      if (!built.inputProofFailures.has(spelling)) {
+        built.inputProofFailures.set(spelling, reason);
       }
     }
   }
@@ -1508,6 +1678,218 @@ function envelopeGraphIndexes(
   return built;
 }
 
+/** Normalize one untrusted predicate proof without filling missing predicates. */
+function normalizeGraphInputObservation(
+  value: unknown,
+  platform: NodeJS.Platform = process.platform,
+): ITtscCompilerTransformation.IInputObservation | undefined {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return undefined;
+  }
+  const entry = value as Record<string, unknown>;
+  const observation: ITtscCompilerTransformation.IInputObservation = {};
+  if (Object.prototype.hasOwnProperty.call(entry, "accessibleEntries")) {
+    const accessible = entry.accessibleEntries;
+    if (
+      typeof accessible !== "object" ||
+      accessible === null ||
+      Array.isArray(accessible)
+    ) {
+      return undefined;
+    }
+    const lists = accessible as Record<string, unknown>;
+    if (
+      !Array.isArray(lists.directories) ||
+      !lists.directories.every(
+        (name): name is string => typeof name === "string",
+      ) ||
+      !Array.isArray(lists.files) ||
+      !lists.files.every((name): name is string => typeof name === "string")
+    ) {
+      return undefined;
+    }
+    observation.accessibleEntries = {
+      directories: [...lists.directories],
+      files: [...lists.files],
+    };
+  }
+  if (Object.prototype.hasOwnProperty.call(entry, "fileExists")) {
+    if (typeof entry.fileExists !== "boolean") return undefined;
+    observation.fileExists = entry.fileExists;
+  }
+  if (Object.prototype.hasOwnProperty.call(entry, "directoryExists")) {
+    if (typeof entry.directoryExists !== "boolean") return undefined;
+    observation.directoryExists = entry.directoryExists;
+  }
+  if (Object.prototype.hasOwnProperty.call(entry, "stat")) {
+    if (
+      entry.stat !== "missing" &&
+      entry.stat !== "file" &&
+      entry.stat !== "directory"
+    ) {
+      return undefined;
+    }
+    observation.stat = entry.stat;
+  }
+  if (Object.prototype.hasOwnProperty.call(entry, "readFile")) {
+    const read = entry.readFile;
+    if (typeof read !== "object" || read === null || Array.isArray(read)) {
+      return undefined;
+    }
+    const result = read as Record<string, unknown>;
+    if (result.ok === false && result.hash === undefined) {
+      observation.readFile = { ok: false };
+    } else if (
+      result.ok === true &&
+      typeof result.hash === "string" &&
+      /^[0-9a-f]{64}$/.test(result.hash)
+    ) {
+      observation.readFile = { hash: result.hash, ok: true };
+    } else {
+      return undefined;
+    }
+  }
+  if (Object.prototype.hasOwnProperty.call(entry, "realpath")) {
+    const realpath = entry.realpath;
+    if (
+      typeof realpath !== "object" ||
+      realpath === null ||
+      Array.isArray(realpath)
+    ) {
+      return undefined;
+    }
+    const result = realpath as Record<string, unknown>;
+    if (result.ok === false && result.path === undefined) {
+      observation.realpath = { ok: false };
+    } else if (
+      result.ok === true &&
+      typeof result.path === "string" &&
+      (platform === "win32" ? path.win32 : path.posix).isAbsolute(result.path)
+    ) {
+      observation.realpath = {
+        ok: true,
+        path: resolveFilesystemPath(result.path, platform),
+      };
+    } else {
+      return undefined;
+    }
+  }
+  return Object.keys(observation).length !== 0 &&
+    graphInputObservationCompatible(observation)
+    ? observation
+    : undefined;
+}
+
+/** Join duplicate lexical keys only when every repeated predicate agrees. */
+function mergeGraphInputObservations(
+  left: ITtscCompilerTransformation.IInputObservation,
+  right: ITtscCompilerTransformation.IInputObservation,
+): ITtscCompilerTransformation.IInputObservation | undefined {
+  for (const property of [
+    "accessibleEntries",
+    "directoryExists",
+    "fileExists",
+    "readFile",
+    "realpath",
+    "stat",
+  ] as const) {
+    if (
+      left[property] !== undefined &&
+      right[property] !== undefined &&
+      JSON.stringify(left[property]) !== JSON.stringify(right[property])
+    ) {
+      return undefined;
+    }
+  }
+  const merged = { ...left, ...right };
+  return graphInputObservationCompatible(merged) ? merged : undefined;
+}
+
+/** Whether one predicate set can describe a single stable filesystem state. */
+function graphInputObservationCompatible(
+  observation: ITtscCompilerTransformation.IInputObservation,
+): boolean {
+  const { accessibleEntries, directoryExists, fileExists, readFile, stat } =
+    observation;
+  const hasAccessibleEntries =
+    accessibleEntries !== undefined &&
+    (accessibleEntries.directories.length !== 0 ||
+      accessibleEntries.files.length !== 0);
+  if (
+    hasAccessibleEntries &&
+    (fileExists === true ||
+      directoryExists === false ||
+      (stat !== undefined && stat !== "directory") ||
+      readFile?.ok === true)
+  ) {
+    return false;
+  }
+  if (fileExists === true && directoryExists === true) return false;
+  if (
+    stat === "directory" &&
+    (fileExists === true || directoryExists === false)
+  ) {
+    return false;
+  }
+  if (stat === "file" && (fileExists === false || directoryExists === true)) {
+    return false;
+  }
+  if (stat === "missing" && (fileExists === true || directoryExists === true)) {
+    return false;
+  }
+  if (
+    readFile?.ok === true &&
+    (fileExists === false ||
+      directoryExists === true ||
+      (stat !== undefined && stat !== "file"))
+  ) {
+    return false;
+  }
+  return true;
+}
+
+/**
+ * Reconstruct a legacy hash/realpath pair only when the rich predicates prove
+ * that projection without collapsing an unreadable file or failed file probe
+ * into generic absence.
+ */
+function legacyProjectionOfGraphInputObservation(
+  observation: ITtscCompilerTransformation.IInputObservation,
+):
+  | { failure?: undefined; hash: string | null; realpath: string | null }
+  | { failure: string } {
+  if (observation.readFile?.ok === true) {
+    return observation.realpath?.ok === true
+      ? {
+          hash: observation.readFile.hash,
+          realpath: observation.realpath.path,
+        }
+      : { failure: "realpath-unavailable" };
+  }
+  const directory =
+    observation.stat === "directory" || observation.directoryExists === true;
+  if (directory) {
+    return observation.realpath?.ok === true
+      ? {
+          hash: hashText("ttsc:host-input:directory\0"),
+          realpath: observation.realpath.path,
+        }
+      : { failure: "realpath-unavailable" };
+  }
+  const file = observation.stat === "file" || observation.fileExists === true;
+  if (file) {
+    return { failure: "content-unavailable" };
+  }
+  const missing =
+    observation.stat === "missing" ||
+    observation.fileExists === false ||
+    observation.directoryExists === false ||
+    observation.readFile?.ok === false;
+  return missing
+    ? { hash: null, realpath: null }
+    : { failure: "unsupported-input-kind" };
+}
+
 /**
  * {@link pathIdentityKey} memoized inside one envelope's derivation state.
  * Callers always pass already-resolved absolute paths, so the input string is a
@@ -1551,21 +1933,8 @@ function collectDeclaredIdentities(
 }
 
 /**
- * Forward every derived watch input for `file` to the adapter's `addWatchFile`
- * hook: the plugin-reported `dependencies[file]` list unioned with the
- * host-owned reference graph's contribution (`reach(edges, file)`, `globals`,
- * `configs`, and resolution candidates).
- *
- * Envelope keys mirror the `typescript` keys (project-relative); values may be
- * project-relative or absolute. Every path is absolutized against the project
- * root and deduplicated; the file itself is dropped (the bundler already
- * watches the module it transforms), and so is every path in the disposed
- * transform scratch tree (see
- * {@link TtscCachedProjectTransform.scratchDirectory}).
- */
-/**
- * Register the failed generation's own project inputs so the host can observe
- * the fix.
+ * Register the failed generation's project and external inputs so the host can
+ * observe the fix.
  *
  * A successful delivery registers the derived watch inputs, which is how a
  * type-only file that no bundler graph contains still invalidates the modules
@@ -1576,76 +1945,200 @@ function collectDeclaredIdentities(
  * arrive: the user repairs a file the bundler does not track, nothing is
  * invalidated, and the error stays on screen (samchon/ttsc#1312).
  *
- * The generation records the project walk even when the compile failed, so the
- * files a fix would touch are exactly what it already holds. The cost is paid
- * only on a failure, and only until the next compile succeeds and narrows the
- * set back to the derived inputs.
+ * A failure envelope can retain exact external input spellings from its graph
+ * and host metadata. A pre-transform typecheck failure may have no graph yet;
+ * its structured diagnostics, or the host's standard diagnostic lines when it
+ * could return only an exception, still name the external files that need a
+ * repair. The cost is paid only on a failure, and only until the next compile
+ * succeeds and narrows the set back to the derived inputs.
  */
 function notifyFailedGenerationInputs(
   hooks: TtscTransformHooks | undefined,
   cached: TtscCachedProjectTransform,
 ): void {
   const addWatchFile = hooks?.addWatchFile;
-  if (addWatchFile === undefined) {
+  const addWatchFiles = hooks?.addWatchFiles;
+  if (addWatchFile === undefined && addWatchFiles === undefined) {
     return;
   }
+  const inputs: TtscWatchInput[] = [];
+  const seen = new Set<string>();
+  const append = (input: string): void => {
+    const spelling = path.resolve(input);
+    if (
+      seen.has(spelling) ||
+      isTransformScratchInput(spelling, cached.scratchDirectory)
+    ) {
+      return;
+    }
+    seen.add(spelling);
+    // No evidence, deliberately. A failed generation is replayed for the rest
+    // of its pass without re-proving its inputs, so the adapter must observe
+    // the current availability itself.
+    inputs.push({ file: spelling });
+  };
   for (const key of Object.keys(cached.inputHashes)) {
-    const input = path.resolve(cached.projectRoot, key);
-    if (isTransformScratchInput(input, cached.scratchDirectory)) {
-      continue;
+    append(path.resolve(cached.projectRoot, key));
+  }
+  // The project walk deliberately excludes node_modules and cannot reach
+  // sibling-project or out-of-root inputs. The generation already retained
+  // their exact lexical spellings, so keep that ownership on the failure path
+  // instead of deriving a narrower second answer.
+  for (const input of cached.externalInputPaths ?? []) {
+    append(input);
+  }
+  if (cached.result.type === "failure") {
+    for (const diagnostic of cached.result.diagnostics) {
+      if (typeof diagnostic.file === "string" && diagnostic.file.length !== 0) {
+        append(path.resolve(cached.projectRoot, diagnostic.file));
+      }
+    }
+  } else if (cached.result.type === "exception") {
+    for (const diagnostic of selectExceptionDiagnosticFiles(
+      cached.result.error,
+    )) {
+      append(path.resolve(cached.projectRoot, diagnostic));
     }
-    // No evidence argument, deliberately. `missing: false` would be a claim
-    // this path cannot back: a failed generation is replayed for the rest of
-    // its pass without re-proving its inputs, so the walk that recorded them
-    // may be older than the delivery, and one of them having been deleted is a
-    // live reason for that compile to have failed. Letting the adapter probe
-    // also routes an absent input to the missing-input poll, which is the only
-    // channel through which restoring it can invalidate anything: a bundler
-    // watch on a path that does not exist registers nothing, and no module
-    // graph carries a type-only input. It costs one `existsSync` per input,
-    // and only where the adapter reads evidence at all, which is Vite serve.
-    addWatchFile(input);
+  }
+  if (addWatchFiles !== undefined) {
+    addWatchFiles(inputs);
+    return;
+  }
+  for (const input of inputs) {
+    addWatchFile!(input.file);
   }
 }
 
+/**
+ * Extract file spellings only from the two standard TypeScript diagnostic
+ * forms.
+ */
+function selectExceptionDiagnosticFiles(error: unknown): string[] {
+  const files: string[] = [];
+  for (const line of formatUnknownError(error).split(/\r?\n/)) {
+    const colon =
+      /^(.+):\d+:\d+\s+-\s+(?:error|warning|suggestion|message)\s+TS\d+:\s+.+$/i.exec(
+        line,
+      );
+    const parenthesized =
+      /^(.+?)\(\d+,\d+\):\s+(?:error|warning|suggestion|message)\s+TS\d+:\s+.+$/i.exec(
+        line,
+      );
+    const file = colon?.[1] ?? parenthesized?.[1];
+    if (file !== undefined && file.trim().length !== 0) {
+      files.push(file.trim());
+    }
+  }
+  return files;
+}
+
+/**
+ * Forward every derived watch input for `file` to the adapter's `addWatchFile`
+ * hook: the plugin-reported `dependencies[file]` list unioned with the
+ * host-owned reference graph's contribution (`reach(edges, file)`, `globals`,
+ * `configs`, and resolution candidates).
+ *
+ * Envelope keys mirror the `typescript` keys (project-relative); values may be
+ * project-relative or absolute. Every path is absolutized against the project
+ * root and deduplicated; the file itself is dropped (the bundler already
+ * watches the module it transforms), and so is every path in the disposed
+ * transform scratch tree (see
+ * {@link TtscCachedProjectTransform.scratchDirectory}).
+ */
 function notifyWatchInputs(
   hooks: TtscTransformHooks | undefined,
   cached: TtscCachedProjectTransform,
   file: string,
 ): void {
   const addWatchFile = hooks?.addWatchFile;
-  if (addWatchFile === undefined) {
+  const addWatchFiles = hooks?.addWatchFiles;
+  if (addWatchFile === undefined && addWatchFiles === undefined) {
     return;
   }
   const state = envelopeDerivation(cached);
   const external = cached.externalInputHashes ?? {};
-  for (const input of selectWatchInputs({
+  const inputs = selectWatchInputs({
     file,
     projectRoot: cached.projectRoot,
     result: cached.result,
     scratchDirectory: cached.scratchDirectory,
     temporaryTsconfig: cached.temporaryTsconfig,
-  })) {
+  }).map((input): TtscWatchInput => {
     // Hand the adapter the identity this generation already resolved and the
-    // existence state it already recorded. Both are memoized per generation,
-    // while an adapter deriving them itself pays a `realpath`, a directory
-    // listing, and an `existsSync` per input on every delivery of every module
-    // (samchon/ttsc#1246).
+    // exact state it already recorded. Both are memoized per generation, while
+    // an adapter deriving them itself pays repeated filesystem reads and can
+    // accidentally attach a later state to an earlier transform.
     const identity = derivationIdentity(state, input);
-    addWatchFile(input, {
+    const spelling = path.resolve(input);
+    const observation = cached.externalInputObservations?.[spelling];
+    const missing =
+      observation?.fileExists === false ||
+      state.graph?.inputProofs.get(spelling)?.hash === null ||
+      external[identity] === MISSING_INPUT_STATE;
+    const projectKey = toProjectKey(
+      cached.projectRoot,
+      input,
+      state.identityContext,
+    );
+    const externalHash = Object.prototype.hasOwnProperty.call(
+      external,
       identity,
-      missing: external[identity] === MISSING_INPUT_STATE,
-    });
+    )
+      ? external[identity]
+      : undefined;
+    const projectHash = Object.prototype.hasOwnProperty.call(
+      cached.inputHashes,
+      projectKey,
+    )
+      ? cached.inputHashes[projectKey]
+      : undefined;
+    const graphRealpaths = cached.externalInputRealpaths ?? {};
+    const stateEvidence: TtscWatchInputState | undefined =
+      observation !== undefined
+        ? { codec: "predicates", observation }
+        : externalHash !== undefined &&
+            Object.prototype.hasOwnProperty.call(graphRealpaths, identity)
+          ? {
+              codec: "graph",
+              hash: externalHash,
+              realpath: graphRealpaths[identity] ?? null,
+            }
+          : externalHash !== undefined
+            ? { codec: "host", hash: externalHash }
+            : projectHash !== undefined
+              ? { codec: "host", hash: projectHash }
+              : undefined;
+    return {
+      file: input,
+      evidence: {
+        identity,
+        missing,
+        ...(stateEvidence === undefined ? {} : { state: stateEvidence }),
+        unavailable:
+          observation?.fileExists === false
+            ? "not-file"
+            : missing
+              ? "missing"
+              : undefined,
+      },
+    };
+  });
+  if (addWatchFiles !== undefined) {
+    addWatchFiles(inputs);
+    return;
+  }
+  for (const input of inputs) {
+    addWatchFile!(input.file, input.evidence);
   }
 }
 
 /**
  * Derive the absolute, deduplicated watch-input list for a single file.
  *
- * By default the derivation is a union: `dependencies[file] ∪ reach(edges,
- * file) ∪ globals ∪ configs`. The plugin-reported list can only widen the
- * host-owned language-semantic bound, never narrow it. Resolution candidates
- * remain part of that host-owned bound in both modes.
+ * By default the derivation unions plugin dependencies, the reachable graph,
+ * globals, configs, importer resolver inputs, and universal resolver inputs.
+ * The plugin-reported list can only widen the host-owned language-semantic
+ * bound, never narrow it. Resolver inputs remain in that bound in both modes.
  *
  * An envelope that lists `file` in `dependenciesComplete` narrows it to
  * `dependencies[file] ∪ configs`: the plugin declared its reported list the
@@ -1657,10 +2150,12 @@ function notifyWatchInputs(
  * volatile keeps the baseline: the two declarations contradict, so the
  * conservative one wins.
  *
- * The derived list is a pure function of the envelope and the file's filesystem
- * identity, so it is computed at most once per generation per file: sibling and
- * repeated deliveries replay the per-envelope memo ({@link envelopeDerivation})
- * instead of re-walking the graph. Returns an empty list on exceptions.
+ * The derived list is a pure function of the envelope and the delivered file's
+ * normalized lexical spelling. Graph traversal uses its filesystem identity,
+ * but lexical inputs exclude only that exact spelling, so two aliases of one
+ * source require distinct lists. Repeated deliveries of one spelling replay the
+ * per-envelope memo ({@link envelopeDerivation}) instead of re-walking the
+ * graph. Returns an empty list on exceptions.
  */
 function selectWatchInputs(props: {
   file: string;
@@ -1674,12 +2169,13 @@ function selectWatchInputs(props: {
   }
   const state = envelopeDerivation(props);
   const fileIdentity = derivationIdentity(state, props.file);
-  const memoized = state.watchInputs.get(fileIdentity);
+  const fileSpelling = path.resolve(props.file);
+  const memoized = state.watchInputs.get(fileSpelling);
   if (memoized !== undefined) {
     return memoized;
   }
   const derived = deriveWatchInputs(state, props, fileIdentity);
-  state.watchInputs.set(fileIdentity, derived);
+  state.watchInputs.set(fileSpelling, derived);
   return derived;
 }
 
@@ -1738,7 +2234,7 @@ function deriveWatchInputs(
       !isVolatileFile(state, props),
   }))
     appendPhysical(input);
-  // Resolution candidates, plugin dependencies, and universal host inputs
+  // Resolver inputs, plugin dependencies, and universal host inputs
   // preserve lexical aliases. Physical deduplication would collapse
   // `alias/selection.cjs` into the selected target path, so a bundler would
   // watch only the target and miss a symlink/junction retarget.
@@ -1759,14 +2255,14 @@ function selectHostInputs(props: {
 }
 
 /**
- * Return the module-resolution paths that can supersede a currently resolved
- * module reachable from `file`. They remain host-owned even when a plugin
- * declares `dependenciesComplete`: plugin code cannot vouch for a compiler
- * resolution change that occurs without any plugin input changing.
+ * Return exact importer-owned and universal resolver inputs for `file`. They
+ * remain host-owned even when a plugin declares `dependenciesComplete`: plugin
+ * code cannot vouch for a compiler resolution or automatic type change that
+ * occurs without any plugin input changing.
  *
- * Candidate entries and their source identities come from the shared
- * per-envelope state, so one delivery scans only the candidates themselves
- * instead of re-resolving every candidate source.
+ * Importer entries and their source identities come from the shared
+ * per-envelope state, so one delivery scans only the recorded inputs instead of
+ * re-resolving every source.
  */
 function selectResolutionCandidateInputs(
   graph: TtscEnvelopeGraphIndexes,
@@ -1777,10 +2273,7 @@ function selectResolutionCandidateInputs(
     result: ITtscCompilerTransformation;
   },
 ): string[] {
-  if (
-    props.result.type === "exception" ||
-    props.result.graph?.candidates === undefined
-  ) {
+  if (props.result.type === "exception" || props.result.graph === undefined) {
     return [];
   }
   const reachable = new Set(
@@ -1788,7 +2281,8 @@ function selectResolutionCandidateInputs(
       derivationIdentity(state, source),
     ),
   );
-  const output: string[] = [];
+  const output: string[] = [...graph.resolutionInputs];
+  if (props.result.graph.candidates === undefined) return output;
   for (const entry of graph.candidates) {
     if (!reachable.has(entry.source)) {
       continue;
@@ -1963,9 +2457,11 @@ function declaresCompleteDependencies(
 }
 
 /**
- * Extract the absolute, deduplicated dependency list for a single file from the
- * compiler result. Mirrors {@link selectTransformedSource}'s key lookup: fast
- * project-relative match first, then a per-envelope identity index. Returns an
+ * Extract the absolute, lexical-spelling-deduplicated dependency list for a
+ * single file from the compiler result. Mirrors
+ * {@link selectTransformedSource}'s key lookup: fast project-relative match
+ * first, then a per-envelope identity index. Distinct lexical aliases must
+ * survive so bundlers observe a later symlink or junction retarget. Returns an
  * empty list on exceptions or when the plugin reported nothing.
  */
 function selectFileDependencies(props: {
@@ -2002,17 +2498,15 @@ function selectFileDependencies(props: {
   }
   const output: string[] = [];
   const seen = new Set<string>();
-  const fileIdentity = derivationIdentity(state, props.file);
   for (const entry of entries) {
     if (typeof entry !== "string" || entry.length === 0) {
       continue;
     }
     const absolute = path.resolve(props.projectRoot, entry);
-    const identity = derivationIdentity(state, absolute);
-    if (identity === fileIdentity || seen.has(identity)) {
+    if (seen.has(absolute)) {
       continue;
     }
-    seen.add(identity);
+    seen.add(absolute);
     output.push(absolute);
   }
   return output;
@@ -2141,6 +2635,10 @@ function matchesCachedSource(
       // out-of-walk snapshot — before any of this pass's deliveries may be
       // settled against it. That proof is what a per-pass recompile used to buy
       // (samchon/ttsc#1300), at a walk instead of a compile.
+      refreshFilesystemClockReference(
+        TRANSFORM_CLOCK_REFERENCE_DIRECTORIES.get(cached),
+        resultFilesystem(cached.result),
+      );
       if (!matchesCompleteInputSnapshot(cached, currentKey, source)) {
         return false;
       }
@@ -2152,6 +2650,10 @@ function matchesCachedSource(
       return true;
     }
   }
+  refreshFilesystemClockReference(
+    TRANSFORM_CLOCK_REFERENCE_DIRECTORIES.get(cached),
+    resultFilesystem(cached.result),
+  );
   if (
     cached.result.type !== "exception" &&
     cached.result.graph !== undefined &&
@@ -2225,20 +2727,21 @@ function matchesNarrowPersistentInputs(
 
 /**
  * Validate one derived input against the generation, skipping the content read
- * while the recorded metadata signature still holds.
+ * while the recorded metadata signature still holds and its freshly minted
+ * clock reference remains safe.
  *
  * Sibling deliveries of one generation share most of their derived inputs, and
  * `graph.globals` is shared by every one of them, so re-reading and re-hashing
  * the whole derived set per delivery multiplies one generation's proven bytes
  * by the module count. The derived set is proven the same way the universal
  * descriptor inputs are ({@link matchesUniversalHostInputs}), under the same
- * rules: an unchanged signature stands in for the content comparison, and any
- * signature change falls back to the full comparison. A signature is recorded
- * only around a read nothing raced, only for a recorded state that came from
- * reading the input rather than from failing to, and only while the observed
- * filesystem's own clock has provably left the stamp's tick
- * ({@link stampSeparable}), so a same-length rewrite inside that tick cannot
- * hide behind an unchanged signature.
+ * rules: a currently separable unchanged signature stands in for the content
+ * comparison, and any signature or clock-ordering change falls back to the full
+ * comparison. A signature is recorded only around a read nothing raced, only
+ * for a recorded state that came from reading the input rather than from
+ * failing to, and only while the observed filesystem's own clock has provably
+ * left the stamp's tick ({@link stampSeparable}), so a same-length rewrite
+ * inside that tick cannot hide behind an unchanged signature.
  *
  * The signature carries the physical identity of both the lexical path and its
  * link target ({@link inputMetadataSignature}), so retargeting a symlink or
@@ -2249,6 +2752,17 @@ function matchesProvenInput(
   state: TtscEnvelopeDerivation,
   input: string,
 ): boolean {
+  const observation = cached.externalInputObservations?.[path.resolve(input)];
+  if (observation !== undefined) {
+    if (
+      observation.fileExists === false &&
+      Object.keys(observation).length === 1 &&
+      notifiesAbsence(cached, input)
+    ) {
+      return true;
+    }
+    return matchesRecordedInput(cached, input);
+  }
   const slot = inputSignatureSlot(cached, state, input);
   if (slot === undefined) {
     return matchesRecordedInput(cached, input);
@@ -2263,7 +2777,11 @@ function matchesProvenInput(
   }
   const filesystem = resultFilesystem(cached.result);
   const before = inputMetadataEvidence(input, filesystem);
-  if (before !== undefined && slot.signatures[slot.key] === before.signature) {
+  if (
+    before !== undefined &&
+    before.separable &&
+    slot.signatures[slot.key] === before.signature
+  ) {
     return true;
   }
   if (!matchesRecordedInput(cached, input)) {
@@ -2325,6 +2843,9 @@ function inputSignatureSlot(
   | { key: string; recorded: string; signatures: Record<string, string> }
   | undefined {
   const identity = derivationIdentity(state, input);
+  if (cached.externalInputObservations?.[path.resolve(input)] !== undefined) {
+    return undefined;
+  }
   const external = cached.externalInputHashes ?? {};
   if (Object.prototype.hasOwnProperty.call(external, identity)) {
     // The recorded hash is identity-keyed because aliases of one physical file
@@ -2384,7 +2905,8 @@ function matchesUniversalHostInputEntries(
     const evidence = inputMetadataEvidence(entry.path, filesystem);
     if (
       entry.signature !== undefined &&
-      evidence?.signature === entry.signature
+      evidence?.signature === entry.signature &&
+      (entry.strict === true || evidence.separable)
     )
       continue;
     if (entry.strict === true) return false;
@@ -2644,8 +3166,8 @@ function captureUniversalHostInputValidation(
 const MISSING_INPUT_STATE = "missing";
 
 /**
- * The highest stamp each observed filesystem clock has provably minted, keyed
- * by the operations object that observes it and, inside, by reporting device.
+ * The current stamp an adapter-owned probe has minted, keyed by the operations
+ * object that observes it and, inside, by reporting device.
  *
  * A filesystem stamps a write once per clock tick, so two same-length writes
  * inside one tick are indistinguishable by metadata alone. A signature may
@@ -2653,72 +3175,46 @@ const MISSING_INPUT_STATE = "missing";
  * it, and that guarantee needs a reference instant the observed filesystem
  * itself produced: once some stamp on the same device is strictly newer than an
  * input's modification stamp, that input's tick is provably over, so any later
- * write must mint a newer stamp and move the signature. That is git's
- * racily-clean index rule, adapted to a read-only contract: where git compares
- * entries against the index file's own timestamp, this floor accumulates every
- * stamp the cache-owned operations report, seeded per generation by
- * {@link mintFilesystemClockReference}.
+ * write must mint a newer stamp and move the signature. This adapts git's
+ * racily-clean index rule: both sides of the comparison come from the same
+ * reporting device, and the newer side is a write the adapter itself made.
  *
- * The process clock never participates: both sides of every comparison are
- * stamps the same filesystem clock minted, at the same granularity, so a
- * filesystem clock running behind (or ahead of) the host process changes
- * nothing.
+ * A timestamp merely observed on another input cannot advance the reference.
+ * Tools may assign modification times, and a filesystem clock can move
+ * backwards independently of the process clock. Neither a passive historical
+ * maximum nor `Date.now()` proves what stamp a write would mint now. The probe
+ * is therefore rewritten immediately before every validation that may reuse a
+ * content signature, and its previous reference is cleared before the write. A
+ * failed refresh or a different reporting device declines the optimization and
+ * retains the content comparison (samchon/ttsc#1344).
  *
- * Accumulating observed stamps is deliberately weaker than git's own reference,
- * which is a single stamp git minted itself. A stamp this floor accepts may
- * instead have been _set_ rather than minted, and a set stamp is dangerous only
- * when it lands in the future: the floor is a maximum, so a restored past stamp
- * never raises it. One future-dated file — a stamp-preserving extraction or
- * copy from a machine whose clock ran ahead — pushes its device's floor past
- * the present and reopens the same-tick window for every other input on that
- * device until the clock catches up. A clock that jumps backwards strands the
- * floor above the present the same way, a different hazard from the constant
- * offset the paragraph above is about: an offset moves both operands together
- * and changes nothing, a jump moves only the present.
- *
- * The minted probe is not enough on its own to replace observed stamps: it
- * lands on the scratch volume, which is frequently not the inputs' volume (a
- * project on `D:` with `TEMP` on `C:`), and a probe-only floor would then
- * decline every _content_ signature, so every input carrying bytes would be
- * re-read on every delivery. A strict blocker keeps its signature either way,
- * because it proves a kind rather than content. Observed stamps keep the common
- * case working; the probe covers the case they cannot, a tree whose files were
- * all written inside one tick.
+ * The probe lives in an adapter-owned temporary directory outside the project.
+ * That directory may be on another volume, such as `C:` when a project lives on
+ * `D:`. Such a split-volume generation safely keeps reading content because no
+ * same-device reference exists; it never substitutes a process-clock guess or
+ * writes a probe into the user's project.
  */
-const FILESYSTEM_CLOCK_FLOORS = new WeakMap<
+const FILESYSTEM_CLOCK_REFERENCES = new WeakMap<
   TtscTransformFilesystemOperations,
   Map<bigint, bigint>
 >();
 
-/** Return one observed filesystem's per-device clock floor, creating it. */
-function filesystemClockFloors(
+/** Return one observed filesystem's current per-device references. */
+function filesystemClockReferences(
   filesystem: TtscTransformFilesystemOperations,
 ): Map<bigint, bigint> {
-  let floors = FILESYSTEM_CLOCK_FLOORS.get(filesystem);
-  if (floors === undefined) {
-    floors = new Map();
-    FILESYSTEM_CLOCK_FLOORS.set(filesystem, floors);
-  }
-  return floors;
-}
-
-/** Raise a device's clock floor with the stamps one observation reported. */
-function observeFilesystemClock(
-  filesystem: TtscTransformFilesystemOperations,
-  stats: fs.BigIntStats,
-): void {
-  const floors = filesystemClockFloors(filesystem);
-  const stamp = stats.mtimeNs > stats.ctimeNs ? stats.mtimeNs : stats.ctimeNs;
-  const current = floors.get(stats.dev);
-  if (current === undefined || stamp > current) {
-    floors.set(stats.dev, stamp);
+  let references = FILESYSTEM_CLOCK_REFERENCES.get(filesystem);
+  if (references === undefined) {
+    references = new Map();
+    FILESYSTEM_CLOCK_REFERENCES.set(filesystem, references);
   }
+  return references;
 }
 
 /**
  * Report whether a later write to the observed path is guaranteed to move its
- * modification stamp: the device's clock floor holds a stamp strictly newer, so
- * the tick that minted the stamp is provably over. The floor was observed
+ * modification stamp: the device's current probe holds a stamp strictly newer,
+ * so the tick that minted the stamp is provably over. The probe was written
  * before the caller's content read began, which is the ordering the guarantee
  * needs — a stamp minted before the read proves every post-read write lands in
  * a newer tick.
@@ -2727,42 +3223,62 @@ function stampSeparable(
   filesystem: TtscTransformFilesystemOperations,
   stats: fs.BigIntStats,
 ): boolean {
-  const floor = filesystemClockFloors(filesystem).get(stats.dev);
-  return floor !== undefined && stats.mtimeNs < floor;
+  const reference = filesystemClockReferences(filesystem).get(stats.dev);
+  return reference !== undefined && stats.mtimeNs < reference;
 }
 
 /**
- * Mint a reference instant for this generation and feed it into the observed
- * filesystem's clock floor.
+ * Replace every prior clock proof with one reference minted by a fresh write.
  *
- * The scratch directory is a write the adapter already owns, deliberately
+ * The reference directory is storage the adapter already owns, deliberately
  * outside the project root, so stamping a probe file there produces a
  * freshly-minted "now" without touching the user's project — the analogue of
  * git writing its index. The probe is observed through the cache-owned
  * operations and keyed by the device those operations report, so it only ever
- * separates stamps on the filesystem that actually minted it; when the scratch
- * volume differs from the inputs' volume, or the observed filesystem cannot see
- * the probe at all, nothing is proven and signature recording simply stays
- * declined until passively observed stamps separate an input on their own.
+ * separates stamps on the filesystem that actually minted it. When its volume
+ * differs from the inputs' volume, or the observed filesystem cannot see the
+ * probe at all, nothing is proven and content comparison continues.
  *
- * Relocating the scratch directory onto the inputs' volume would make the probe
- * universal, but it would also move every compiler and plugin temporary write
- * into the project's parent (frequently a monorepo root or a home directory)
- * for those layouts. That is a product decision about where ttsc writes, not a
- * property of this rule, so the cross-volume case degrades to more reads here
- * rather than being bought with it.
+ * Forcing the reference onto the inputs' volume would require writing into the
+ * user's project or an otherwise unowned neighboring directory. That is not a
+ * valid price for this optimization, so the cross-volume case degrades to more
+ * reads instead.
  */
-function mintFilesystemClockReference(
-  scratchDirectory: string,
+function refreshFilesystemClockReference(
+  referenceDirectory: string | undefined,
   filesystem: TtscTransformFilesystemOperations,
 ): void {
+  const references = filesystemClockReferences(filesystem);
+  references.clear();
+  if (referenceDirectory === undefined) return;
+  try {
+    const probe = path.join(referenceDirectory, "clock-reference");
+    fs.writeFileSync(probe, `${process.hrtime.bigint()}\n`);
+    const stats = filesystem.lstat(probe);
+    if (stats.isFile()) {
+      references.set(stats.dev, stats.mtimeNs);
+    }
+  } catch {
+    // A failed refresh leaves no reference, so content comparison continues.
+    references.clear();
+  }
+}
+
+/** Remove only the known probe and its now-empty owned directory. */
+function disposeFilesystemClockReference(referenceDirectory: string): void {
+  try {
+    fs.rmSync(path.join(referenceDirectory, "clock-reference"), {
+      force: true,
+    });
+  } catch {
+    // The probe may already have disappeared; the directory removal below is
+    // still safe because it is deliberately non-recursive.
+  }
   try {
-    const probe = path.join(scratchDirectory, "clock-reference");
-    fs.writeFileSync(probe, "");
-    observeFilesystemClock(filesystem, filesystem.lstat(probe));
+    fs.rmdirSync(referenceDirectory);
   } catch {
-    // The absence of a reference declines signature recording; it never
-    // invalidates a generation.
+    // Eviction schedules cleanup without awaiting its Promise. A foreign entry
+    // or a concurrent removal leaves, at worst, an empty temporary directory.
   }
 }
 
@@ -2797,12 +3313,10 @@ function inputMetadataEvidence(
 ): TtscInputMetadataEvidence | undefined {
   try {
     const link = filesystem.lstat(file);
-    observeFilesystemClock(filesystem, link);
     let target = link;
     if (link.isSymbolicLink()) {
       try {
         target = filesystem.statBigInt(file);
-        observeFilesystemClock(filesystem, target);
       } catch {
         // Keep a broken link in the existing-input manifest. Its own metadata
         // stays stable while the target is missing, and the first successful
@@ -2873,7 +3387,21 @@ function graphInputStateHash(
   file: string,
   filesystem: TtscTransformFilesystemOperations = DEFAULT_FILESYSTEM_OPERATIONS,
 ): string | null {
+  const kind = compilerStatKind(file, filesystem);
+  const readHash = graphInputReadHash(file, filesystem, kind);
+  if (readHash !== null) return readHash;
+  return kind === "directory" ? hashText("ttsc:host-input:directory\0") : null;
+}
+
+/** Hash only a successful compiler-style ReadFile result, without kind fallback. */
+function graphInputReadHash(
+  file: string,
+  filesystem: TtscTransformFilesystemOperations = DEFAULT_FILESYSTEM_OPERATIONS,
+  observedKind?: "directory" | "file" | "missing",
+): string | null {
+  const kind = observedKind ?? compilerStatKind(file, filesystem);
   try {
+    if (kind === "directory") return null;
     const bytes = filesystem.readFile(file);
     if (bytes.length >= 2 && bytes[0] === 0xff && bytes[1] === 0xfe) {
       const even = bytes.subarray(
@@ -2898,14 +3426,179 @@ function graphInputStateHash(
         : bytes;
     return hashText(content);
   } catch {
+    return null;
+  }
+}
+
+/** Current result of TypeScript-Go's Stat predicate. */
+function compilerStatKind(
+  file: string,
+  filesystem: TtscTransformFilesystemOperations,
+): "directory" | "file" | "missing" {
+  try {
+    return filesystem.stat(file).isDirectory() ? "directory" : "file";
+  } catch {
+    return "missing";
+  }
+}
+
+/** Return the exact recorded predicates that no longer hold for one spelling. */
+function graphInputObservationFailures(
+  file: string,
+  observation: ITtscCompilerTransformation.IInputObservation,
+  filesystem: TtscTransformFilesystemOperations,
+  identities: FilesystemPathIdentityContext,
+): string[] {
+  const failures: string[] = [];
+  if (observation.accessibleEntries !== undefined) {
+    const current = compilerAccessibleEntries(file, filesystem);
+    if (
+      JSON.stringify(current) !== JSON.stringify(observation.accessibleEntries)
+    ) {
+      failures.push("accessible-entries-changed");
+    }
+  }
+  const kind =
+    observation.fileExists !== undefined ||
+    observation.directoryExists !== undefined ||
+    observation.stat !== undefined ||
+    observation.readFile !== undefined
+      ? compilerStatKind(file, filesystem)
+      : undefined;
+  if (
+    observation.fileExists !== undefined &&
+    (kind === "file") !== observation.fileExists
+  ) {
+    failures.push("file-exists-changed");
+  }
+  if (
+    observation.directoryExists !== undefined &&
+    (kind === "directory") !== observation.directoryExists
+  ) {
+    failures.push("directory-exists-changed");
+  }
+  if (observation.stat !== undefined && kind !== observation.stat) {
+    failures.push("stat-changed");
+  }
+  if (observation.readFile !== undefined) {
+    const currentHash = graphInputReadHash(file, filesystem, kind);
+    if (
+      (observation.readFile.ok && currentHash !== observation.readFile.hash) ||
+      (!observation.readFile.ok && currentHash !== null)
+    ) {
+      failures.push("read-file-changed");
+    }
+  }
+  if (observation.realpath !== undefined) {
+    const currentRealpath = compilerInputRealpathObservation(file, filesystem);
+    if (
+      observation.realpath.ok !== currentRealpath.ok ||
+      (observation.realpath.ok &&
+        currentRealpath.ok &&
+        !sameHostInputRealpath(
+          observation.realpath.path,
+          currentRealpath.path,
+          identities,
+        ))
+    ) {
+      failures.push("realpath-changed");
+    }
+  }
+  return failures;
+}
+
+/** Replay TypeScript-Go's accessible-entry classification and sorted order. */
+function compilerAccessibleEntries(
+  directory: string,
+  filesystem: TtscTransformFilesystemOperations,
+): NonNullable<
+  ITtscCompilerTransformation.IInputObservation["accessibleEntries"]
+> {
+  const directories: string[] = [];
+  const files: string[] = [];
+  const pathApi = filesystem.platform === "win32" ? path.win32 : path.posix;
+  let entries: fs.Dirent[];
+  try {
+    entries = filesystem.readdir(directory);
+  } catch {
+    return { directories, files };
+  }
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      directories.push(entry.name);
+      continue;
+    }
+    if (entry.isFile()) {
+      files.push(entry.name);
+      continue;
+    }
+    if (!entry.isSymbolicLink()) continue;
     try {
-      return filesystem.stat(file).isDirectory()
-        ? hashText("ttsc:host-input:directory\0")
-        : null;
+      const target = filesystem.stat(pathApi.join(directory, entry.name));
+      if (target.isDirectory()) directories.push(entry.name);
+      else if (target.isFile()) files.push(entry.name);
     } catch {
-      return null;
+      // TypeScript-Go omits inaccessible and broken linked entries.
     }
   }
+  directories.sort();
+  files.sort();
+  return { directories, files };
+}
+
+/** Validate one predicate-preserving graph proof against a filesystem view. */
+export function validateGraphInputObservation(
+  file: string,
+  observation: ITtscCompilerTransformation.IInputObservation,
+  filesystem: TtscTransformFilesystemOperations = DEFAULT_FILESYSTEM_OPERATIONS,
+): string[] {
+  const normalized = normalizeGraphInputObservation(
+    observation,
+    filesystem.platform,
+  );
+  if (normalized === undefined) return ["proof-conflict"];
+  return graphInputObservationFailures(
+    file,
+    normalized,
+    filesystem,
+    createHostPathIdentityContext(filesystem),
+  );
+}
+
+/** Whether every compiler-time predicate still returns its recorded value. */
+function matchesGraphInputObservation(
+  file: string,
+  observation: ITtscCompilerTransformation.IInputObservation,
+  filesystem: TtscTransformFilesystemOperations,
+  identities: FilesystemPathIdentityContext,
+): boolean {
+  return (
+    graphInputObservationFailures(file, observation, filesystem, identities)
+      .length === 0
+  );
+}
+
+/** Replay TypeScript-Go's Realpath result, including its lexical fallback. */
+function compilerInputRealpathObservation(
+  file: string,
+  filesystem: TtscTransformFilesystemOperations,
+): NonNullable<ITtscCompilerTransformation.IInputObservation["realpath"]> {
+  try {
+    const realpath = filesystem.realpath(file);
+    return realpath.length === 0
+      ? { ok: false }
+      : {
+          ok: true,
+          path: resolveFilesystemPath(realpath, filesystem.platform),
+        };
+  } catch {
+    // TypeScript-Go's OS and io filesystems return the cleaned input spelling
+    // when native realpath resolution fails; they do not expose the failure.
+    return {
+      ok: true,
+      path: resolveFilesystemPath(file, filesystem.platform),
+    };
+  }
 }
 
 /** Physical target selected by a lexical host-input path. */
@@ -3093,6 +3786,9 @@ function matchesExternalInputRealpaths(
   const state = envelopeDerivation(cached);
   const filesystem = resultFilesystem(cached.result);
   for (const input of cached.externalInputPaths ?? []) {
+    if (cached.externalInputObservations?.[path.resolve(input)] !== undefined) {
+      continue;
+    }
     const identity = derivationIdentity(state, input);
     if (!Object.prototype.hasOwnProperty.call(expected, identity)) continue;
     if (
@@ -3122,6 +3818,7 @@ function captureExternalInputSnapshot(
   complete: boolean;
   failures: TtscGenerationProofFailures;
   hashes: Record<string, string>;
+  observations: Record<string, ITtscCompilerTransformation.IInputObservation>;
   realpaths: Record<string, string | null>;
   signatures: Record<string, string>;
 } {
@@ -3131,17 +3828,19 @@ function captureExternalInputSnapshot(
   // A non-declaration transform output is a compiler-realized source even when
   // a malformed or legacy graph omitted its node. Its output was computed from
   // compiler-time bytes, so a post-compile host read cannot prove coherence.
-  const transformSources = new Set<string>();
+  const transformSourceSpellings = new Set<string>();
   if (cached.result.type === "success") {
     for (const output of Object.keys(cached.result.typescript)) {
       if (!isDeclarationFile(output)) {
-        transformSources.add(
-          derivationIdentity(state, path.resolve(cached.projectRoot, output)),
-        );
+        transformSourceSpellings.add(path.resolve(cached.projectRoot, output));
       }
     }
   }
   const hashes: Record<string, string> = {};
+  const observations: Record<
+    string,
+    ITtscCompilerTransformation.IInputObservation
+  > = {};
   const realpaths: Record<string, string | null> = {};
   const signatures: Record<string, string> = {};
   const failures = createGenerationProofFailures();
@@ -3162,29 +3861,64 @@ function captureExternalInputSnapshot(
   };
   for (const input of paths) {
     const identity = derivationIdentity(state, input);
-    // A member the envelope reported only as a resolution candidate falls
+    const spelling = path.resolve(input);
+    const predicateObservation = graph.inputObservations.get(spelling);
+    const predicateConflict = graph.inputObservationConflicts.has(spelling);
+    if (
+      graph.speculative.has(spelling) &&
+      (predicateObservation !== undefined || predicateConflict)
+    ) {
+      if (predicateConflict || predicateObservation === undefined) {
+        complete = false;
+        recordGenerationProofFailure(failures, {
+          domain: "external",
+          kind: "graph-proof-conflict",
+          detail: graph.inputProofFailures.get(spelling),
+          path: input,
+        });
+        continue;
+      }
+      const mismatches = graphInputObservationFailures(
+        input,
+        predicateObservation,
+        filesystem,
+        state.identityContext,
+      );
+      if (mismatches.length !== 0) complete = false;
+      for (const kind of mismatches) {
+        recordGenerationProofFailure(failures, {
+          domain: "external",
+          kind: `graph-${kind}`,
+          path: input,
+        });
+      }
+      observations[spelling] = predicateObservation;
+      continue;
+    }
+    // A member the envelope reported only as a resolver input falls
     // through to the recorded-state branch below, the same evidence a
     // plugin-declared dependency path carries. Its absence still invalidates
     // the generation when it appears, because `missing` is recorded state.
-    const realizedTransformSource = transformSources.has(identity);
+    const realizedTransformSource = transformSourceSpellings.has(spelling);
     const speculativeOnly =
       !realizedTransformSource &&
-      graph.speculative.has(identity) &&
-      !graph.inputProofs.has(identity) &&
-      !graph.inputProofConflicts.has(identity);
+      graph.speculative.has(spelling) &&
+      !graph.inputProofs.has(spelling) &&
+      !graph.inputProofConflicts.has(spelling) &&
+      !graph.inputProofFailures.has(spelling);
     if (
-      (realizedTransformSource || graph.members.has(identity)) &&
+      (realizedTransformSource || graph.memberSpellings.has(spelling)) &&
       !speculativeOnly
     ) {
-      const proof = graph.inputProofs.get(identity);
-      if (proof === undefined || graph.inputProofConflicts.has(identity)) {
+      const proof = graph.inputProofs.get(spelling);
+      if (proof === undefined || graph.inputProofConflicts.has(spelling)) {
         complete = false;
         recordGenerationProofFailure(failures, {
           domain: "external",
-          kind: graph.inputProofConflicts.has(identity)
+          kind: graph.inputProofConflicts.has(spelling)
             ? "graph-proof-conflict"
             : "graph-proof-missing",
-          detail: graph.inputProofFailures.get(identity),
+          detail: graph.inputProofFailures.get(spelling),
           path: input,
         });
         continue;
@@ -3231,7 +3965,14 @@ function captureExternalInputSnapshot(
     hashes[identity] = hash ?? MISSING_INPUT_STATE;
     if (hash !== null) record(input, before, after);
   }
-  return { complete, failures, hashes, realpaths, signatures };
+  return {
+    complete,
+    failures,
+    hashes,
+    observations,
+    realpaths,
+    signatures,
+  };
 }
 
 /** Explain every graph member that no longer matches the compiler's state. */
@@ -3243,6 +3984,7 @@ function compilerGraphInputProofFailures(
     cached.result.type === "exception" ||
     cached.result.graph === undefined ||
     (cached.result.graph.inputHashes === undefined &&
+      cached.result.graph.inputObservations === undefined &&
       cached.result.graph.inputRealpaths === undefined &&
       cached.result.graph.inputProofFailures === undefined)
   ) {
@@ -3251,38 +3993,105 @@ function compilerGraphInputProofFailures(
     // where a post-compile snapshot cannot prove the compiler's generation.
     return failures;
   }
-  const state = envelopeDerivation(cached);
-  const filesystem = resultFilesystem(cached.result);
-  const graph = envelopeGraphIndexes(state, cached);
-  for (const identity of graph.members) {
-    const proof = graph.inputProofs.get(identity);
-    const spelling =
-      proof?.path ?? graph.spellings.get(identity) ?? cached.projectRoot;
+  const state = envelopeDerivation(cached);
+  const filesystem = resultFilesystem(cached.result);
+  const graph = envelopeGraphIndexes(state, cached);
+  const predicateSpellings = new Set<string>();
+  const predicateConflictSpellings = new Set<string>();
+  for (const [spelling, observation] of graph.inputObservations) {
+    predicateSpellings.add(spelling);
+    for (const kind of graphInputObservationFailures(
+      spelling,
+      observation,
+      filesystem,
+      state.identityContext,
+    )) {
+      recordGenerationProofFailure(failures, {
+        domain: "graph",
+        kind,
+        path: spelling,
+      });
+    }
+  }
+  for (const spelling of graph.inputObservationConflicts) {
+    predicateSpellings.add(spelling);
+    predicateConflictSpellings.add(spelling);
+    recordGenerationProofFailure(failures, {
+      domain: "graph",
+      kind: "proof-conflict",
+      detail: graph.inputProofFailures.get(spelling),
+      path: spelling,
+    });
+  }
+  for (const spelling of graph.memberSpellings) {
+    const proof = graph.inputProofs.get(spelling);
     if (isTransformScratchInput(spelling, cached.scratchDirectory)) {
       continue;
     }
-    // A speculative candidate has no compile-time read to prove. Requiring one
-    // would void every generation of every project whose resolution passes over
-    // a higher-priority spelling, which is every project with a dependency
-    // typed by a declaration file (samchon/ttsc#1245). It is validated instead
-    // against the state {@link captureExternalInputSnapshot} recorded for it.
-    if (proof === undefined && graph.speculative.has(identity)) {
+    if (predicateConflictSpellings.has(spelling)) {
       continue;
     }
-    if (graph.inputProofConflicts.has(identity)) {
+    if (graph.inputProofConflicts.has(spelling)) {
       recordGenerationProofFailure(failures, {
         domain: "graph",
         kind: "proof-conflict",
-        detail: graph.inputProofFailures.get(identity),
+        detail: graph.inputProofFailures.get(spelling),
+        path: spelling,
+      });
+      continue;
+    }
+    if (graph.inputProofFailures.has(spelling)) {
+      recordGenerationProofFailure(failures, {
+        domain: "graph",
+        kind: "proof-missing",
+        detail: graph.inputProofFailures.get(spelling),
         path: spelling,
       });
       continue;
     }
+    const observation = graph.inputObservations.get(spelling);
+    if (observation !== undefined && proof !== undefined) {
+      const projection = legacyProjectionOfGraphInputObservation(observation);
+      if (
+        projection.failure !== undefined ||
+        projection.hash !== proof.hash ||
+        !sameHostInputRealpath(
+          projection.realpath,
+          proof.realpath,
+          state.identityContext,
+        )
+      ) {
+        recordGenerationProofFailure(failures, {
+          domain: "graph",
+          kind: "proof-conflict",
+          detail: projection.failure,
+          path: spelling,
+        });
+      }
+      // The rich predicates were already replayed above. Their legacy
+      // projection is an internal producer-consistency check, never a reason
+      // to read the same filesystem input again. A projection that cannot
+      // represent the observation is itself inconsistent with a supplied
+      // legacy proof, rather than permission to trust either representation.
+      continue;
+    }
+    if (
+      graph.speculative.has(spelling) &&
+      predicateSpellings.has(spelling) &&
+      !graph.inputProofFailures.has(spelling)
+    ) {
+      continue;
+    }
+    // A legacy sidecar can report a resolver candidate without a compiler
+    // predicate. Validate it against the generation snapshot instead.
+    if (proof === undefined && graph.speculative.has(spelling)) {
+      continue;
+    }
     if (proof === undefined) {
       recordGenerationProofFailure(failures, {
         domain: "graph",
         kind: "proof-missing",
-        detail: graph.inputProofFailures.get(identity),
+        detail: graph.inputProofFailures.get(spelling),
         path: spelling,
       });
       continue;
@@ -3331,6 +4140,15 @@ function matchesRecordedInput(
     ? cached.inputHashes[projectKey]
     : undefined;
   const identity = derivationIdentity(state, input);
+  const observation = cached.externalInputObservations?.[path.resolve(input)];
+  if (observation !== undefined) {
+    return matchesGraphInputObservation(
+      input,
+      observation,
+      filesystem,
+      state.identityContext,
+    );
+  }
   const externalHash = (cached.externalInputHashes ?? {})[identity];
   const externalRealpaths = cached.externalInputRealpaths;
   const graphInput =
@@ -3386,7 +4204,31 @@ export function collectProjectInputHashes(
   filesystem: TtscTransformFilesystemOperations = DEFAULT_FILESYSTEM_OPERATIONS,
   policy?: ITtscProjectMembershipPolicy,
 ): Record<string, string> {
-  return collectProjectInputSnapshot(
+  return collectProjectInputHashSnapshot(
+    projectRoot,
+    identities,
+    filesystem,
+    policy,
+  ).hashes;
+}
+
+/** One project-walk hash set together with its completeness proof. */
+export interface TtscProjectInputHashSnapshot {
+  complete: boolean;
+  hashes: Record<string, string>;
+}
+
+/**
+ * Hash the project walk and retain whether every attempted directory and file
+ * was observed coherently. Cache-key hosts must reject an incomplete set.
+ */
+export function collectProjectInputHashSnapshot(
+  projectRoot: string,
+  identities: FilesystemPathIdentityContext = createHostPathIdentityContext(),
+  filesystem: TtscTransformFilesystemOperations = DEFAULT_FILESYSTEM_OPERATIONS,
+  policy?: ITtscProjectMembershipPolicy,
+): TtscProjectInputHashSnapshot {
+  const snapshot = collectProjectInputSnapshot(
     projectRoot,
     identities,
     filesystem,
@@ -3394,7 +4236,11 @@ export function collectProjectInputHashes(
     {
       policy,
     },
-  ).hashes;
+  );
+  return {
+    complete: snapshot.complete && snapshot.directoryComplete,
+    hashes: snapshot.hashes,
+  };
 }
 
 /** Hash project files and snapshot the directory topology in one walk. */
@@ -3453,11 +4299,12 @@ function collectProjectInputSnapshot(
       const before = inputMetadataEvidence(file, filesystem);
       // A file whose signature still equals the one captured around the read
       // that produced the recorded hash carries that content, so the whole
-      // project does not have to be re-read to prove one delivery. A signature
-      // that was already proven stays proven: its stamp has not moved since the
-      // clock provably left its tick.
+      // project does not have to be re-read to prove one delivery. Recheck the
+      // clock ordering as well: rollback can make a formerly safe floor unable
+      // to answer for a new write (samchon/ttsc#1344).
       if (
         before !== undefined &&
+        before.separable &&
         proven !== undefined &&
         proven.signatures[key] === before.signature &&
         Object.prototype.hasOwnProperty.call(proven.hashes, key)
@@ -3673,7 +4520,7 @@ function walkProjectInputs(
 
 /**
  * Return a directory's metadata stamp, used to detect that its membership moved
- * _while_ the walk was enumerating it, and to feed the observed-clock floor.
+ * _while_ the walk was enumerating it.
  *
  * This is the right instrument for that job and the wrong one for comparing two
  * generations: it moves for ignored entries too. {@link walkProjectInputs}
@@ -3685,9 +4532,6 @@ function projectDirectorySignature(
 ): string | undefined {
   try {
     const stats = filesystem.statBigInt(directory);
-    // Directory stamps are minted by the same clock as file stamps, so every
-    // walk observation also raises the clock floor that separates them.
-    observeFilesystemClock(filesystem, stats);
     if (!stats.isDirectory()) {
       return undefined;
     }
@@ -3761,6 +4605,24 @@ function openDirectoryWatch(
   return { close: () => watcher.close() };
 }
 
+/** Detach and close every watcher, then preserve the first cleanup failure. */
+function closeDirectoryWatches(watchers: { close: () => void }[]): void {
+  const owned = watchers.splice(0);
+  let failed = false;
+  let failure: unknown;
+  for (const watcher of owned) {
+    try {
+      watcher.close();
+    } catch (error) {
+      if (!failed) {
+        failed = true;
+        failure = error;
+      }
+    }
+  }
+  if (failed) throw failure;
+}
+
 /** Watch every walked directory for membership changes after generation. */
 async function createProjectMutationTracker(
   directories: readonly TtscProjectDirectorySnapshot[],
@@ -3791,10 +4653,7 @@ async function createProjectMutationTracker(
     return tracker;
   }
   const watchers: { close: () => void }[] = [];
-  tracker.close = () => {
-    for (const watcher of watchers) watcher.close();
-    watchers.length = 0;
-  };
+  tracker.close = () => closeDirectoryWatches(watchers);
   for (const directory of directories) {
     try {
       watchers.push(
@@ -3896,10 +4755,7 @@ async function createHostInputMutationTracker(
     return tracker;
   }
   const watchers: { close: () => void }[] = [];
-  tracker.close = () => {
-    for (const watcher of watchers) watcher.close();
-    watchers.length = 0;
-  };
+  tracker.close = () => closeDirectoryWatches(watchers);
   for (const location of locations) {
     try {
       const names = new Set(location.names);
@@ -4137,14 +4993,36 @@ async function registerWindowsProjectMutationTracker(
     if (active === undefined) return;
     broker.trackers.delete(id);
     active.ready();
-    broker.child.send?.({ id, op: "remove" });
+    let failed = false;
+    let failure: unknown;
+    try {
+      broker.child.send?.({ id, op: "remove" });
+    } catch (error) {
+      failed = true;
+      failure = error;
+    }
     if (broker.trackers.size === 0) {
-      broker.child.disconnect?.();
-      broker.child.kill();
       if (windowsProjectMutationBroker === broker) {
         windowsProjectMutationBroker = undefined;
       }
+      try {
+        broker.child.disconnect?.();
+      } catch (error) {
+        if (!failed) {
+          failed = true;
+          failure = error;
+        }
+      }
+      try {
+        broker.child.kill();
+      } catch (error) {
+        if (!failed) {
+          failed = true;
+          failure = error;
+        }
+      }
     }
+    if (failed) throw failure;
   };
   broker.child.send?.({
     allEvents,
@@ -4528,10 +5406,251 @@ export function collectExternalInputHashes(
   return hashes;
 }
 
+/** Capture the stable file predicate used by implicit project discovery. */
+export function captureWatchInputFileBaseline(
+  file: string,
+  filesystem: TtscTransformFilesystemOperations = DEFAULT_FILESYSTEM_OPERATIONS,
+): TtscWatchInputFileBaseline | undefined {
+  const capture = (): TtscWatchInputFileBaseline => {
+    const identities = createHostPathIdentityContext(filesystem);
+    let fileExists = false;
+    try {
+      fileExists = filesystem.stat(file).isFile();
+    } catch {
+      // Project discovery rejects every candidate not proven to be a file.
+    }
+    return {
+      fileExists,
+      identity: pathIdentityKey(file, identities),
+    };
+  };
+  try {
+    const before = capture();
+    const after = capture();
+    return stableStringify(before) === stableStringify(after)
+      ? after
+      : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * Capture one stable main-process baseline that can be compared with any
+ * generation-owned watch-input evidence. Two equal broad observations are
+ * required so a cache key never publishes a torn path state.
+ */
+export function captureWatchInputBaseline(
+  file: string,
+  filesystem: TtscTransformFilesystemOperations = DEFAULT_FILESYSTEM_OPERATIONS,
+): TtscWatchInputBaseline | undefined {
+  const capture = (): TtscWatchInputBaseline => {
+    const identities = createHostPathIdentityContext(filesystem);
+    const stat = compilerStatKind(file, filesystem);
+    return {
+      directoryExists: stat === "directory",
+      fileExists: stat === "file",
+      graphHash: graphInputStateHash(file, filesystem) ?? MISSING_INPUT_STATE,
+      graphReadHash: graphInputReadHash(file, filesystem),
+      hostHash: hostInputStateHash(file, filesystem) ?? MISSING_INPUT_STATE,
+      identity: pathIdentityKey(file, identities),
+      realpath: compilerInputRealpathObservation(file, filesystem),
+      stat,
+    };
+  };
+  try {
+    const before = capture();
+    const after = capture();
+    return stableStringify(before) === stableStringify(after)
+      ? after
+      : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/** Compare generation evidence with the main process's exact key baseline. */
+export function watchInputEvidenceMatchesBaseline(
+  evidence: TtscWatchInputEvidence,
+  baseline: TtscWatchInputKeyBaseline,
+): boolean {
+  if (
+    !isWatchInputKeyBaseline(baseline) ||
+    evidence.identity !== baseline.identity ||
+    evidence.state === undefined
+  ) {
+    return false;
+  }
+  const broad = broadWatchInputBaseline(baseline);
+  if (evidence.state.codec === "host") {
+    return broad !== undefined && evidence.state.hash === broad.hostHash;
+  }
+  const identities = createHostPathIdentityContext();
+  if (evidence.state.codec === "graph") {
+    return (
+      broad !== undefined &&
+      evidence.state.hash === broad.graphHash &&
+      sameHostInputRealpath(
+        evidence.state.realpath,
+        broad.realpath.ok ? broad.realpath.path : null,
+        identities,
+      )
+    );
+  }
+  const observation = evidence.state.observation;
+  if (
+    observation.fileExists !== undefined &&
+    observation.fileExists !== baseline.fileExists
+  ) {
+    return false;
+  }
+  if (
+    observation.directoryExists !== undefined &&
+    (broad === undefined ||
+      observation.directoryExists !== broad.directoryExists)
+  ) {
+    return false;
+  }
+  if (
+    observation.stat !== undefined &&
+    (broad === undefined || observation.stat !== broad.stat)
+  ) {
+    return false;
+  }
+  if (
+    observation.readFile !== undefined &&
+    (broad === undefined ||
+      (observation.readFile.ok &&
+        observation.readFile.hash !== broad.graphReadHash) ||
+      (!observation.readFile.ok && broad.graphReadHash !== null))
+  ) {
+    return false;
+  }
+  if (observation.realpath !== undefined) {
+    if (broad === undefined) {
+      return false;
+    }
+    if (observation.realpath.ok !== broad.realpath.ok) {
+      return false;
+    }
+    if (
+      observation.realpath.ok &&
+      broad.realpath.ok &&
+      !sameHostInputRealpath(
+        observation.realpath.path,
+        broad.realpath.path,
+        identities,
+      )
+    ) {
+      return false;
+    }
+  }
+  return true;
+}
+
+/** Validate the complete narrow or broad shape stored in a key baseline. */
+export function isWatchInputKeyBaseline(
+  baseline: unknown,
+): baseline is TtscWatchInputKeyBaseline {
+  if (!isPlainRecord(baseline)) return false;
+  const keys = Object.keys(baseline).sort();
+  if (
+    typeof baseline.fileExists !== "boolean" ||
+    typeof baseline.identity !== "string" ||
+    !isAbsoluteFilesystemPath(baseline.identity)
+  ) {
+    return false;
+  }
+  if (stableStringify(keys) === stableStringify(["fileExists", "identity"])) {
+    return true;
+  }
+  if (
+    stableStringify(keys) !==
+    stableStringify([
+      "directoryExists",
+      "fileExists",
+      "graphHash",
+      "graphReadHash",
+      "hostHash",
+      "identity",
+      "realpath",
+      "stat",
+    ])
+  ) {
+    return false;
+  }
+  if (
+    typeof baseline.directoryExists !== "boolean" ||
+    !isWatchInputStateHash(baseline.graphHash) ||
+    !(
+      baseline.graphReadHash === null || isContentHash(baseline.graphReadHash)
+    ) ||
+    !isWatchInputStateHash(baseline.hostHash) ||
+    !isWatchInputRealpathBaseline(baseline.realpath) ||
+    (baseline.stat !== "directory" &&
+      baseline.stat !== "file" &&
+      baseline.stat !== "missing")
+  ) {
+    return false;
+  }
+  return (
+    baseline.fileExists === (baseline.stat === "file") &&
+    baseline.directoryExists === (baseline.stat === "directory")
+  );
+}
+
+/** Whether an unknown value is one ordinary JSON object. */
+function isPlainRecord(value: unknown): value is Record<string, unknown> {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+
+/** Whether one identity can name an absolute path on either supported syntax. */
+function isAbsoluteFilesystemPath(value: string): boolean {
+  return path.posix.isAbsolute(value) || path.win32.isAbsolute(value);
+}
+
+/** Whether a serialized hash is a content digest. */
+function isContentHash(value: unknown): value is string {
+  return typeof value === "string" && /^[0-9a-f]{64}$/.test(value);
+}
+
+/** Whether a baseline state is either a digest or the missing marker. */
+function isWatchInputStateHash(value: unknown): value is string {
+  return value === MISSING_INPUT_STATE || isContentHash(value);
+}
+
+/** Validate the serialized Realpath predicate as an exact discriminated union. */
+function isWatchInputRealpathBaseline(
+  value: unknown,
+): value is TtscWatchInputBaseline["realpath"] {
+  if (!isPlainRecord(value) || typeof value.ok !== "boolean") return false;
+  const keys = Object.keys(value).sort();
+  if (value.ok === false) {
+    return stableStringify(keys) === stableStringify(["ok"]);
+  }
+  return (
+    stableStringify(keys) === stableStringify(["ok", "path"]) &&
+    typeof value.path === "string" &&
+    isAbsoluteFilesystemPath(value.path)
+  );
+}
+
+/** Return a broad baseline after the complete entry has been validated. */
+function broadWatchInputBaseline(
+  baseline: TtscWatchInputKeyBaseline,
+): TtscWatchInputBaseline | undefined {
+  return "directoryExists" in baseline ? baseline : undefined;
+}
+
 /**
  * Re-check a cached mixed graph/dependency input set with its owning codec,
  * reusing the recorded hash of any input whose metadata signature still holds
- * and reporting the signatures this pass captured.
+ * under a freshly minted same-device reference and reporting the signatures
+ * this pass captured.
  *
  * The caller adopts those signatures only once every input is proven unchanged,
  * so a signature never outlives the content comparison that justified it.
@@ -4557,6 +5676,20 @@ function matchesCachedExternalInputs(cached: TtscCachedProjectTransform): {
     Object.keys(cached.externalInputHashes ?? {})) {
     const identity = derivationIdentity(state, file);
     const spelling = path.resolve(file);
+    const observation = cached.externalInputObservations?.[spelling];
+    if (observation !== undefined) {
+      if (
+        !matchesGraphInputObservation(
+          file,
+          observation,
+          filesystem,
+          state.identityContext,
+        )
+      ) {
+        matches = false;
+      }
+      continue;
+    }
     // Reuse the recorded hash of an out-of-walk input whose signature still
     // equals the one captured around the read that proved it. The signature is
     // keyed by this exact spelling, so an alias of the same physical file
@@ -4566,6 +5699,7 @@ function matchesCachedExternalInputs(cached: TtscCachedProjectTransform): {
       before !== undefined &&
       Object.prototype.hasOwnProperty.call(recordedSignatures, spelling) &&
       Object.prototype.hasOwnProperty.call(recordedHashes, identity) &&
+      before.separable &&
       before.signature === recordedSignatures[spelling]
     ) {
       continue;
@@ -4624,6 +5758,14 @@ function selectExternalInputPaths(props: {
   const identities = createHostPathIdentityContext(filesystem);
   const resolutionCandidates = new Set<string>();
   const graph = props.result.graph;
+  const graphState = envelopeDerivation({
+    projectRoot: props.projectRoot,
+    result: props.result,
+  });
+  const graphIndexes = envelopeGraphIndexes(graphState, {
+    projectRoot: props.projectRoot,
+    result: props.result,
+  });
   // Every transform output key names the source file whose transformed text it
   // carries. Keep an out-of-walk source in the external snapshot instead of
   // injecting it into the project-walk key universe (samchon/ttsc#252).
@@ -4635,7 +5777,11 @@ function selectExternalInputPaths(props: {
         members.push(...targets);
       }
     }
-    for (const listed of [graph.globals, graph.configs]) {
+    for (const listed of [
+      graph.globals,
+      graph.configs,
+      graph.resolutionInputs,
+    ]) {
       if (Array.isArray(listed)) {
         members.push(...listed);
       }
@@ -4650,7 +5796,12 @@ function selectExternalInputPaths(props: {
         }
         const absolute = path.resolve(props.projectRoot, candidate);
         members.push(candidate);
-        resolutionCandidates.add(pathIdentityKey(absolute, identities));
+        resolutionCandidates.add(path.resolve(absolute));
+      }
+    }
+    for (const input of graph.resolutionInputs ?? []) {
+      if (typeof input === "string" && input.length !== 0) {
+        resolutionCandidates.add(path.resolve(props.projectRoot, input));
       }
     }
   }
@@ -4666,9 +5817,7 @@ function selectExternalInputPaths(props: {
         // Plugin discovery inputs deliberately include absent config and
         // resolution probes. A project walk cannot snapshot a path that does
         // not exist yet, even when its spelling lies below projectRoot.
-        resolutionCandidates.add(
-          pathIdentityKey(path.resolve(props.projectRoot, input), identities),
-        );
+        resolutionCandidates.add(path.resolve(props.projectRoot, input));
       }
     }
   }
@@ -4685,8 +5834,11 @@ function selectExternalInputPaths(props: {
     const absolute = path.resolve(props.projectRoot, member);
     const spelling = path.resolve(absolute);
     const identity = pathIdentityKey(absolute, identities);
+    const observation = graphIndexes.inputObservations.get(spelling);
     const missingCandidate =
-      resolutionCandidates.has(identity) && !filesystem.exists(absolute);
+      resolutionCandidates.has(spelling) &&
+      (observation?.fileExists === false ||
+        (observation === undefined && !filesystem.exists(absolute)));
     if (
       identity === excluded ||
       isTransformScratchInput(absolute, props.scratchDirectory) ||
@@ -4744,6 +5896,14 @@ function selectNotifiableAbsentInputs(props: {
     return empty;
   }
   const identities = createHostPathIdentityContext(props.filesystem);
+  const graphState = envelopeDerivation({
+    projectRoot: props.projectRoot,
+    result: props.result,
+  });
+  const graphIndexes = envelopeGraphIndexes(graphState, {
+    projectRoot: props.projectRoot,
+    result: props.result,
+  });
   const excluded =
     props.temporaryTsconfig === undefined
       ? undefined
@@ -4757,7 +5917,10 @@ function selectNotifiableAbsentInputs(props: {
   // them. Sharing a set would let one silently answer for the other.
   const seen = new Set<string>();
   const chain = new Set<string>();
-  for (const candidates of Object.values(graph.candidates ?? {})) {
+  for (const candidates of [
+    ...Object.values(graph.candidates ?? {}),
+    graph.resolutionInputs ?? [],
+  ]) {
     if (!Array.isArray(candidates)) {
       continue;
     }
@@ -4767,12 +5930,16 @@ function selectNotifiableAbsentInputs(props: {
       }
       const absolute = path.resolve(props.projectRoot, candidate);
       const spelling = path.resolve(absolute);
+      const observation = graphIndexes.inputObservations.get(spelling);
+      const absentAsFile =
+        observation?.fileExists === false ||
+        (observation === undefined && !props.filesystem.exists(absolute));
       if (
         seen.has(spelling) ||
         isTransformScratchInput(absolute, props.scratchDirectory) ||
         (excluded !== undefined &&
           pathIdentityKey(absolute, identities) === excluded) ||
-        props.filesystem.exists(absolute)
+        !absentAsFile
       ) {
         continue;
       }
@@ -4882,20 +6049,6 @@ function insideProject(directory: string, projectRoot: string): boolean {
  */
 const NOTIFIABLE_ABSENCE_DIRECTORY_LIMIT = 512;
 
-function isIgnoredProjectDirectory(name: string): boolean {
-  // The residue of what used to be a fifteen-name list, kept to the three
-  // directories no tsconfig can name and no program can contain: the VCS
-  // store, the package manager's tree (TypeScript's own default `exclude`
-  // carries it too), and ttsc's own plugin cache. Everything else the old list
-  // guessed at, and guessing was wrong in both directions: a bundler writing
-  // to an unnamed directory changed project membership with its own output,
-  // while a real source directory named `build` or `temp` was dropped from the
-  // walk and its new files were never seen (samchon/ttsc#1307). Those are now
-  // decided by `ITtscProjectMembershipPolicy`, which reads the configuration
-  // that actually knows.
-  return name === ".git" || name === ".ttsc" || name === "node_modules";
-}
-
 /**
  * Whether the resolved configuration keeps this directory out of the program.
  *
@@ -5181,6 +6334,8 @@ function selectDeclaredProjectInputKeys(props: {
     for (const input of graph.globals) add(input);
   if (Array.isArray(graph.configs))
     for (const input of graph.configs) add(input);
+  if (Array.isArray(graph.resolutionInputs))
+    for (const input of graph.resolutionInputs) add(input);
   for (const [source, candidates] of Object.entries(graph.candidates ?? {})) {
     add(source);
     if (Array.isArray(candidates)) for (const entry of candidates) add(entry);
@@ -5478,6 +6633,10 @@ function createUnstableGenerationError(
   lines.push(
     "  Stop writes to the listed inputs before compilation, or fix the producer that omitted or contradicted the listed proof.",
   );
+  // The failed snapshot remains useful as immutable retry evidence, but it can
+  // never serve a module. Release every live resource before its terminal
+  // verdict is retained in the cache.
+  disposeCachedTransform(validation.cached);
   return new TtscUnstableGenerationError(lines.join("\n"), validation);
 }
 
@@ -5504,9 +6663,10 @@ async function transformProject(props: {
   for (let attempt = 0; attempt < TRANSFORM_GENERATION_ATTEMPTS; attempt += 1) {
     const cached = await captureTransformGeneration(props);
     if (
-      !props.trackProjectMembership ||
-      cached.result.type !== "success" ||
-      cached.projectSnapshotComplete === true
+      cached.configStateComplete !== false &&
+      (!props.trackProjectMembership ||
+        cached.result.type !== "success" ||
+        cached.projectSnapshotComplete === true)
     ) {
       return cached;
     }
@@ -5552,23 +6712,54 @@ async function captureTransformGeneration(props: {
     projectRoot,
     props.filesystem,
   );
+  let clockReferenceDirectory: string | undefined;
+  let retainClockReferenceDirectory = false;
   let tracker: TtscProjectMutationTracker | undefined;
   let retainTracker = false;
   let hostInputTracker: TtscProjectMutationTracker | undefined;
   let candidateTracker: TtscProjectMutationTracker | undefined;
   let retainHostInputTracker = false;
   let retainCandidateTracker = false;
+  let captured: TtscCachedProjectTransform | undefined;
   try {
-    const configured = createTransformTsconfig(props, scratchDirectory);
+    if (props.trackProjectMembership) {
+      try {
+        clockReferenceDirectory = createTransformScratchDirectory(
+          projectRoot,
+          props.filesystem,
+        );
+      } catch {
+        // A retained probe is an optimization. The live compiler scratch can
+        // still authorize capture, and later validations will compare bytes.
+      }
+    }
+    const materializesConfig =
+      Object.keys(props.compilerOptions).length !== 0 ||
+      Object.keys(props.aliasPaths).length !== 0;
+    const tsconfigState = readTransformTsconfigState(
+      props.tsconfig,
+      materializesConfig,
+    );
+    const configured = createTransformTsconfig(
+      props,
+      scratchDirectory,
+      tsconfigState,
+    );
     const temporaryTsconfig =
       configured.path === props.tsconfig ? undefined : configured.path;
+    const compilerEnvironment = transformScratchEnvironment(scratchDirectory);
+    if (temporaryTsconfig === undefined) {
+      delete compilerEnvironment[TTSC_SEMANTIC_CONFIG_PATH];
+    } else {
+      compilerEnvironment[TTSC_SEMANTIC_CONFIG_PATH] = props.tsconfig;
+    }
     const identities = createHostPathIdentityContext(props.filesystem);
     // Read from the project's own tsconfig rather than the generated one: a
     // relative `outDir` is anchored at the config that declares it, and the
     // generated config lives in a system temp directory. The caller's
     // compiler-options overlay still wins, since it wins for the compile too.
     const membershipPolicy = mergeMembershipPolicyOverlay(
-      readProjectMembershipPolicy(props.tsconfig),
+      tsconfigState.membershipPolicy,
       props.compilerOptions,
       projectRoot,
     );
@@ -5599,14 +6790,21 @@ async function captureTransformGeneration(props: {
         plugins: props.plugins,
         projectRoot,
         tsconfig: configured.path,
-        env: transformScratchEnvironment(scratchDirectory),
+        env: compilerEnvironment,
       }).transform(),
     );
     TRANSFORM_RESULT_FILESYSTEM.set(result, props.filesystem);
+    const configStable =
+      tsconfigState.signature === undefined ||
+      tsconfigState.signature ===
+        readTransformTsconfigState(props.tsconfig, true).signature;
     // Mint the generation's clock reference after the compile and before any
     // signature-recording read below, so every input written before the
     // compile sits in a provably finished tick when its signature is captured.
-    mintFilesystemClockReference(scratchDirectory, props.filesystem);
+    refreshFilesystemClockReference(
+      clockReferenceDirectory ?? scratchDirectory,
+      props.filesystem,
+    );
     const persistentHostInputs = selectPersistentHostInputs({
       filesystem: props.filesystem,
       projectRoot,
@@ -5684,6 +6882,7 @@ async function captureTransformGeneration(props: {
       scratchDirectory,
     });
     const walkStable =
+      configStable &&
       walkSnapshotComplete(before, declaredInputs) &&
       walkSnapshotComplete(inputSnapshot, declaredInputs) &&
       sameHashes(before.hashes, inputSnapshot.hashes, declaredInputs) &&
@@ -5734,6 +6933,7 @@ async function captureTransformGeneration(props: {
       externalInputHashes: {},
       externalInputRealpaths: {},
       externalInputPaths,
+      configStateComplete: configStable,
       inputHashes: inputSnapshot.hashes,
       inputSignatures: inputSnapshot.provenSignatures,
       membershipPolicy,
@@ -5759,6 +6959,7 @@ async function captureTransformGeneration(props: {
       externalInputPaths,
     );
     cached.externalInputHashes = externalInputSnapshot.hashes;
+    cached.externalInputObservations = externalInputSnapshot.observations;
     cached.externalInputRealpaths = externalInputSnapshot.realpaths;
     cached.externalInputSignatures = externalInputSnapshot.signatures;
     // Evaluate every half, rather than short-circuiting, so a generation that
@@ -5766,6 +6967,13 @@ async function captureTransformGeneration(props: {
     // only on the failing path, where the alternative is recompiling the whole
     // project for every remaining module.
     const failures = createGenerationProofFailures();
+    if (!configStable) {
+      recordGenerationProofFailure(failures, {
+        domain: "project",
+        kind: "config-state-changed",
+        path: props.tsconfig,
+      });
+    }
     if (!walkStable) {
       recordProjectSnapshotFailures(failures, {
         before,
@@ -5834,28 +7042,80 @@ async function captureTransformGeneration(props: {
     retainTracker = notifying && tracker !== undefined;
     retainHostInputTracker = notifying && hostInputTracker !== undefined;
     retainCandidateTracker = notifying && candidateTracker !== undefined;
-    return cached;
+    if (clockReferenceDirectory !== undefined) {
+      retainClockReferenceDirectory = true;
+    }
+    captured = cached;
   } finally {
+    let cleanupFailed = false;
+    let cleanupFailure: unknown;
     try {
-      if (!retainTracker && tracker !== undefined) {
-        tracker.close();
-      }
-    } finally {
       try {
-        if (!retainHostInputTracker && hostInputTracker !== undefined) {
-          hostInputTracker.close();
+        if (!retainTracker && tracker !== undefined) {
+          tracker.close();
         }
       } finally {
         try {
-          if (!retainCandidateTracker && candidateTracker !== undefined) {
-            candidateTracker.close();
+          if (!retainHostInputTracker && hostInputTracker !== undefined) {
+            hostInputTracker.close();
           }
         } finally {
-          fs.rmSync(scratchDirectory, { force: true, recursive: true });
+          try {
+            if (!retainCandidateTracker && candidateTracker !== undefined) {
+              candidateTracker.close();
+            }
+          } finally {
+            try {
+              fs.rmSync(scratchDirectory, { force: true, recursive: true });
+            } finally {
+              if (
+                !retainClockReferenceDirectory &&
+                clockReferenceDirectory !== undefined
+              ) {
+                disposeFilesystemClockReference(clockReferenceDirectory);
+              }
+            }
+          }
+        }
+      }
+    } catch (error) {
+      cleanupFailed = true;
+      cleanupFailure = error;
+    }
+    if (cleanupFailed) {
+      // The generation never leaves this function when local cleanup fails.
+      // Close everything that was waiting to transfer, without letting a
+      // secondary teardown error replace the first failure.
+      for (const retained of [
+        retainTracker ? tracker : undefined,
+        retainHostInputTracker ? hostInputTracker : undefined,
+        retainCandidateTracker ? candidateTracker : undefined,
+      ]) {
+        try {
+          retained?.close();
+        } catch {
+          // Continue releasing the other generation-owned resources.
         }
       }
+      if (
+        retainClockReferenceDirectory &&
+        clockReferenceDirectory !== undefined
+      ) {
+        disposeFilesystemClockReference(clockReferenceDirectory);
+      }
+      throw cleanupFailure;
     }
   }
+  if (captured === undefined) {
+    throw new Error("ttsc: transform generation capture produced no result");
+  }
+  if (clockReferenceDirectory !== undefined) {
+    TRANSFORM_CLOCK_REFERENCE_DIRECTORIES.set(
+      captured,
+      clockReferenceDirectory,
+    );
+  }
+  return captured;
 }
 
 /** Exclude disposed transform scratch from live host-input tracking. */
@@ -5884,6 +7144,50 @@ function selectPersistentHostInputs(props: {
   });
 }
 
+interface ITransformTsconfigState {
+  effectivePaths: Record<string, string[]>;
+  membershipPolicy: ITtscProjectMembershipPolicy;
+  signature?: string;
+  templateCompilerOptions: Record<string, unknown>;
+  templateFileSpecs: Record<string, unknown>;
+}
+
+/** Read every wrapper-dependent view and bind it to one config-chain state. */
+function readTransformTsconfigState(
+  tsconfig: string,
+  materializesConfig: boolean,
+): ITransformTsconfigState {
+  const membershipPolicy = readProjectMembershipPolicy(tsconfig);
+  if (!materializesConfig) {
+    return {
+      effectivePaths: {},
+      membershipPolicy,
+      templateCompilerOptions: {},
+      templateFileSpecs: {},
+    };
+  }
+  const effectivePaths = readEffectiveTsconfigPaths(tsconfig);
+  const templateCompilerOptions =
+    readEffectiveTsconfigTemplateCompilerOptions(tsconfig);
+  const templateFileSpecs = readEffectiveTsconfigTemplateFileSpecs(tsconfig);
+  const sources = readTsconfigSourceSnapshot(tsconfig);
+  return {
+    effectivePaths,
+    membershipPolicy,
+    signature: hashText(
+      JSON.stringify({
+        effectivePaths,
+        membershipPolicy,
+        sources,
+        templateCompilerOptions,
+        templateFileSpecs,
+      }),
+    ),
+    templateCompilerOptions,
+    templateFileSpecs,
+  };
+}
+
 function createTransformTsconfig(
   props: {
     aliasPaths: Record<string, string[]>;
@@ -5891,24 +7195,34 @@ function createTransformTsconfig(
     tsconfig: string;
   },
   scratchDirectory: string,
+  state: ITransformTsconfigState,
 ): { path: string } {
-  const compilerOptions = normalizeCompilerOptionsForGeneratedTsconfig(
+  const overlay = normalizeCompilerOptionsForGeneratedTsconfig(
     {
       ...props.compilerOptions,
-      ...createAliasCompilerOptions(props),
+      ...createAliasCompilerOptions(props, state.effectivePaths),
     },
     path.dirname(props.tsconfig),
   );
-  if (Object.keys(compilerOptions).length === 0) {
+  if (Object.keys(overlay).length === 0) {
     return { path: props.tsconfig };
   }
 
+  // A `${configDir}` value survives every `extends` hop and binds only at the
+  // final consumer. The scratch wrapper would therefore move it out of the
+  // project even for an unrelated overlay. Re-state only those inherited
+  // values as absolute paths so the wrapper remains semantically transparent.
+  const compilerOptions = {
+    ...state.templateCompilerOptions,
+    ...overlay,
+  };
   const file = path.join(scratchDirectory, "tsconfig.json");
   fs.writeFileSync(
     file,
     JSON.stringify(
       {
         extends: normalizePath(props.tsconfig),
+        ...state.templateFileSpecs,
         compilerOptions,
       },
       null,
@@ -6067,16 +7381,18 @@ function normalizeCompilerOptionsForGeneratedTsconfig(
 ): Record<string, unknown> {
   const output = { ...compilerOptions };
   // Scalar path fields: resolve each against the original tsconfig directory.
-  for (const key of ["declarationDir", "outDir", "rootDir"]) {
+  for (const key of CONFIG_DIR_TEMPLATE_SCALAR_OPTIONS) {
     if (typeof output[key] === "string") {
-      output[key] = path.resolve(tsconfigDir, output[key]);
+      output[key] = resolveConfigDirTemplatePath(tsconfigDir, output[key]);
     }
   }
   // Array path fields: resolve each element individually.
-  for (const key of ["rootDirs", "typeRoots"]) {
+  for (const key of CONFIG_DIR_TEMPLATE_LIST_OPTIONS) {
     if (Array.isArray(output[key])) {
       output[key] = output[key].map((entry) =>
-        typeof entry === "string" ? path.resolve(tsconfigDir, entry) : entry,
+        typeof entry === "string"
+          ? resolveConfigDirTemplatePath(tsconfigDir, entry)
+          : entry,
       );
     }
   }
@@ -6136,17 +7452,20 @@ function normalizePluginConfigForGeneratedTsconfig(
  * No `baseUrl` is emitted: TypeScript-Go removed the option (TS5102), and all
  * targets are absolute so none is needed.
  */
-function createAliasCompilerOptions(props: {
-  aliasPaths: Record<string, string[]>;
-  compilerOptions: Record<string, unknown>;
-  tsconfig: string;
-}): Record<string, unknown> {
+function createAliasCompilerOptions(
+  props: {
+    aliasPaths: Record<string, string[]>;
+    compilerOptions: Record<string, unknown>;
+    tsconfig: string;
+  },
+  effectivePaths: Record<string, string[]>,
+): Record<string, unknown> {
   if (Object.keys(props.aliasPaths).length === 0) {
     return {};
   }
   return {
     paths: {
-      ...readEffectiveTsconfigPaths(props.tsconfig),
+      ...effectivePaths,
       ...readPaths(props.compilerOptions.paths),
       ...props.aliasPaths,
     },
@@ -6531,9 +7850,9 @@ function stripTerminalEscapes(text: string): string {
  *
  * If `tsconfig` is supplied it is returned as-is (absolute) or resolved from
  * `process.cwd()` (relative). Otherwise the function walks ancestor directories
- * starting at `file`'s directory, returning the first `tsconfig.json` found.
- * Falls back to `<cwd>/tsconfig.json` when no ancestor contains one; the
- * compiler will error if that file does not exist, which is the correct
+ * starting at `file`'s directory, returning the first `tsconfig.json` proven to
+ * be a file. Falls back to `<cwd>/tsconfig.json` when no ancestor contains one;
+ * the compiler will error if that file does not exist, which is the correct
  * behavior for a mis-configured project.
  */
 function resolveTsconfig(
@@ -6547,18 +7866,9 @@ function resolveTsconfig(
       : path.resolve(process.cwd(), tsconfig);
   }
 
-  let current = path.dirname(file);
-  while (true) {
-    const candidate = path.join(current, "tsconfig.json");
-    if (filesystem.exists(candidate)) {
-      return candidate;
-    }
-    const parent = path.dirname(current);
-    // Reached filesystem root, stop walking.
-    if (parent === current) {
-      break;
-    }
-    current = parent;
+  const discovered = findNearestProjectTsconfig(path.dirname(file), filesystem);
+  if (discovered !== undefined) {
+    return discovered;
   }
   return path.resolve(process.cwd(), "tsconfig.json");
 }