@ttsc/unplugin 0.31.0 → 0.31.2

package/src/core/transform/validation/matchesCachedSource.ts

@@ -10,6 +10,7 @@ import { pathIdentityKey } from "../filesystem/pathIdentityKey";
 import { hostInputStateHash } from "../inputs/hostInputStateHash";
 import { toProjectKey } from "../project/toProjectKey";
 import { hashText } from "../utils/hashText";
+import { TtscGenerationProof } from "./TtscGenerationProof";
 import { matchesCompleteInputSnapshot } from "./matchesCompleteInputSnapshot";
 import { matchesNarrowPersistentInputs } from "./matchesNarrowPersistentInputs";
 import { nativeInputPredicatesHold } from "./nativeInputPredicatesHold";
@@ -24,17 +25,19 @@ import { notificationsProveProgramUnchanged } from "./notificationsProveProgramU
  * no source comparison. A cache with a delivery epoch can use that comparison
  * alone for a stable generation's first delivery of each module in the current
  * pass, once the pass's own first delivery has proven the whole generation
- * still matches the filesystem. An incomplete generation may not take this
- * shortcut: otherwise a sibling output captured during a filesystem race could
- * still be served once. Later graph-bearing requests validate the file's
- * derived input set and project membership. A failed result is a diagnostic of
- * the whole loaded program, so its repair cannot be proved by one delivered
- * output's dependency closure. Failed and graph-free envelopes conservatively
- * validate the complete project and out-of-walk snapshots, reusing qualified
- * signatures. A mismatch rejects this generation for the delivery; its caller
- * chooses replacement or capture. Delivered text that differs while the disk
- * still holds the bytes the generation compiled is not one: it is reported and
- * served, since the compile read the disk (samchon/ttsc#1394).
+ * still matches the filesystem. Incomplete generations cannot claim complete
+ * proof. A coherent local success admitted only because its observer was
+ * unavailable may share first deliveries in its exact nonwatching pass through
+ * TtscGenerationProof; it cannot cross passes or earn persistent authority.
+ * Later graph-bearing requests validate the file's derived input set and
+ * project membership. A failed result is a diagnostic of the whole loaded
+ * program, so its repair cannot be proved by one delivered output's dependency
+ * closure. Failed and graph-free envelopes conservatively validate the complete
+ * project and out-of-walk snapshots, reusing qualified signatures. A mismatch
+ * rejects this generation for the delivery; its caller chooses replacement or
+ * capture. Delivered text that differs while the disk still holds the bytes the
+ * generation compiled is not one: it is reported and served, since the compile
+ * read the disk (samchon/ttsc#1394).
  *
  * Its place in the adapter's invalidation model, and the units beside it, are
  * mapped in the maintainer page
@@ -42,7 +45,7 @@ import { notificationsProveProgramUnchanged } from "./notificationsProveProgramU
  *
  * @evidence contracts/common.md#principled-implementation Delivered source, generation completeness, pass identity and notification authority choose between first-delivery proof, derived-input validation and complete snapshots; divergent editor text never substitutes for compiler disk inputs.
  * @evidence contracts/common.md#clear-and-simple-design This admission boundary chooses the required proof while dedicated validators own membership, universal inputs and content comparisons.
- * @evidence contracts/common.md#prohibited-implementation-shortcuts An incomplete generation cannot earn a first-delivery shortcut; inherited object members cannot invent a project baseline, and losing watcher proof falls back to recorded-state validation.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts An incomplete generation cannot claim complete snapshot authority; only separately admitted coherent local success can share first deliveries of its exact nonwatching pass; inherited object members cannot invent a project baseline, and losing watcher proof falls back to recorded-state validation.
  * @evidence contracts/common.md#meaningful-documentation Separate native paragraphs explain disk-versus-delivered authority, epoch qualification, fallback and related maintainer guidance before tags.
  * @evidence contracts/portability.md#os-neutral-implementation Project membership and path identity use recorded compiler case policy and injected native operations; OS names do not certify case sensitivity or watcher capabilities.
  * @evidence contracts/performance.md#bound-retention-and-release-resources
@@ -52,13 +55,13 @@ import { notificationsProveProgramUnchanged } from "./notificationsProveProgramU
  *   while validators replace current signature/directory witnesses. No new
  *   independent handle or historical epoch collection is acquired here.
  * @evidence contracts/performance.md#efficient-algorithms Every admission first replays all generation-owned typed config predicates; this mandatory cost includes native queries, file bytes or directory membership independently of watcher/epoch qualification.
- *   Fresh-only rejection precedes native identity work. Baseline-bearing paths
+ *   Unsupported fresh-only rejection precedes source baseline work. Baseline-bearing paths
  *   hash delivered text and divergent paths read/hash host bytes; unrelated
  *   absent outputs can return before that hash after an initial K-output index.
  *   Epoch-qualified first checkpoints share the complete proof. Other paths
  *   pay derived-input or complete project/external/universal proof costs,
  *   including path/byte populations, native observations and clock refresh.
- * @evidence contracts/performance.md#reuse-equivalent-work Typed config predicate replay is not cached by this coordinator and remains mandatory even when the following existing shortcut shares other proof.  A complete generation earns one whole-snapshot proof per new delivery epoch; later first deliveries share it, while repeated or persistent deliveries revalidate their authoritative dependency scope.
+ * @evidence contracts/performance.md#reuse-equivalent-work Typed config predicate replay remains mandatory for every delivery and shares only the current synchronous transaction with nested validators; immutable membership is indexed separately.  A complete generation earns one whole-snapshot proof per new delivery epoch; later first deliveries share it, while repeated or persistent deliveries revalidate their authoritative dependency scope.
  */
 export function matchesCachedSource(
   /** Generation retaining recorded baselines and distinct proof authority. */
@@ -69,9 +72,11 @@ export function matchesCachedSource(
   source: string,
   /** Current host pass, or undefined for persistent input validation. */
   epoch: number | undefined,
+  proof?: TtscGenerationProof.Transaction,
 ): boolean {
-  if (!nativeInputPredicatesHold(cached)) return false;
-  if (cached.freshDeliveryOnly === true) return false;
+  if (!nativeInputPredicatesHold(cached, proof)) return false;
+  const pass = TtscGenerationProof.sharesPass(cached, file, epoch);
+  if (cached.freshDeliveryOnly === true && !pass) return false;
   const identities = envelopeDerivation(cached).identityContext;
   const currentKey = toProjectKey(cached.projectRoot, file, identities);
   const identity = pathIdentityKey(file, identities);
@@ -102,7 +107,7 @@ export function matchesCachedSource(
     if (!outputs.has(identity)) {
       // While the watchers prove the program unchanged, the module is still
       // outside it, and no walk is needed to say so (samchon/ttsc#1398).
-      if (notificationsProveProgramUnchanged(cached)) {
+      if (notificationsProveProgramUnchanged(cached, proof)) {
         return true;
       }
       // Root discovery deliberately never hashed this unrelated module. Its
@@ -113,7 +118,7 @@ export function matchesCachedSource(
         TRANSFORM_CLOCK_REFERENCE_DIRECTORIES.get(cached),
         resultFilesystem(cached.result),
       );
-      return matchesCompleteInputSnapshot(cached);
+      return matchesCompleteInputSnapshot(cached, proof);
     }
   }
   if (expected !== hashText(source)) {
@@ -130,6 +135,7 @@ export function matchesCachedSource(
     }
     reportDivergentDelivery(cached, file);
   }
+  if (pass) return true;
   if (epoch !== undefined && cached.projectSnapshotComplete === true) {
     if (cached.deliveryEpoch !== epoch) {
       // The pass's first delivery. The generation was settled against an
@@ -142,7 +148,7 @@ export function matchesCachedSource(
         TRANSFORM_CLOCK_REFERENCE_DIRECTORIES.get(cached),
         resultFilesystem(cached.result),
       );
-      if (!matchesCompleteInputSnapshot(cached)) {
+      if (!matchesCompleteInputSnapshot(cached, proof)) {
         return false;
       }
       cached.deliveryEpoch = epoch;
@@ -165,7 +171,7 @@ export function matchesCachedSource(
     cached.projectMutationTracker !== undefined &&
     cached.hostInputMutationTracker !== undefined
   ) {
-    const narrow = matchesNarrowPersistentInputs(cached, file);
+    const narrow = matchesNarrowPersistentInputs(cached, file, proof);
     if (narrow !== undefined) {
       return narrow;
     }
@@ -173,5 +179,5 @@ export function matchesCachedSource(
     // produced. Losing the proof is not evidence of a change, so fall through
     // to the snapshot the entry still carries.
   }
-  return matchesCompleteInputSnapshot(cached);
+  return matchesCompleteInputSnapshot(cached, proof);
 }

package/src/core/transform/validation/matchesCompleteInputSnapshot.ts

@@ -3,6 +3,7 @@ import { resultFilesystem } from "../cache/resultFilesystem";
 import { declaredProjectInputKeys } from "../envelope/declaredProjectInputKeys";
 import { envelopeDerivation } from "../envelope/envelopeDerivation";
 import { collectProjectInputSnapshot } from "../project/collectProjectInputSnapshot";
+import type { TtscGenerationProof } from "./TtscGenerationProof";
 import { matchesCachedExternalInputs } from "./matchesCachedExternalInputs";
 import { matchesExternalInputRealpaths } from "./matchesExternalInputRealpaths";
 import { matchesUniversalHostInputEntries } from "./matchesUniversalHostInputEntries";
@@ -43,7 +44,7 @@ import { walkSnapshotComplete } from "./walkSnapshotComplete";
  *   target scans, signature entry materialization/adoption and native identity
  *   work add population/path/digit costs; unresolved content and predicate
  *   replay add bytes/listings. Early rejection skips subsequent domains.
- * @evidence contracts/performance.md#reuse-equivalent-work Typed config predicate replay is not cached by this coordinator and remains mandatory even when the following existing shortcut shares other proof.  Qualified separable signatures avoid repeated content reads under the caller's refreshed clock. Successful aggregate proof adopts earned project/external signatures and clears unverified flags; it neither clears recorded changes/failed flags nor makes later quiet notifications sufficient without their other admission conditions.
+ * @evidence contracts/performance.md#reuse-equivalent-work Typed config predicates remain mandatory on every delivery. An exact-generation synchronous transaction may share their current replay across nested validators, but no pass or notification shortcut authorizes a later delivery to skip them.  Qualified separable signatures avoid repeated content reads under the caller's refreshed clock. Successful aggregate proof adopts earned project/external signatures and clears unverified flags; it neither clears recorded changes/failed flags nor makes later quiet notifications sufficient without their other admission conditions.
  */
 export function matchesCompleteInputSnapshot(
   /**
@@ -51,8 +52,9 @@ export function matchesCompleteInputSnapshot(
    * proof.
    */
   cached: TtscCachedProjectTransform,
+  proof?: TtscGenerationProof.Transaction,
 ): boolean {
-  if (!nativeInputPredicatesHold(cached)) return false;
+  if (!nativeInputPredicatesHold(cached, proof)) return false;
   if (
     cached.projectSnapshotComplete !== true ||
     cached.projectDirectories === undefined
@@ -72,7 +74,7 @@ export function matchesCompleteInputSnapshot(
     hostValidation === undefined ||
     !matchesUniversalHostInputEntries(cached, hostValidation) ||
     !matchesUniversalHostInputProbes(cached, hostValidation) ||
-    !matchesUniversalHostInputTrees(cached, hostValidation)
+    !matchesUniversalHostInputTrees(cached, hostValidation, proof)
   ) {
     return false;
   }

package/src/core/transform/validation/matchesNarrowPersistentInputs.ts

@@ -5,6 +5,7 @@ import { envelopeDerivation } from "../envelope/envelopeDerivation";
 import { selectWatchInputs } from "../envelope/selectWatchInputs";
 import { notificationsProveMembership } from "../tracker/notificationsProveMembership";
 import { reportsMembershipChange } from "../tracker/reportsMembershipChange";
+import type { TtscGenerationProof } from "./TtscGenerationProof";
 import { matchesProvenInput } from "./matchesProvenInput";
 import { matchesUniversalHostInputs } from "./matchesUniversalHostInputs";
 
@@ -49,6 +50,7 @@ export function matchesNarrowPersistentInputs(
   cached: TtscCachedProjectTransform,
   /** Delivered file spelling selecting this envelope's dependency closure. */
   file: string,
+  proof?: TtscGenerationProof.Transaction,
 ): boolean | undefined {
   if (reportsMembershipChange(cached)) {
     return false;
@@ -61,7 +63,7 @@ export function matchesNarrowPersistentInputs(
   if (hostValidation === undefined) {
     return undefined;
   }
-  if (!matchesUniversalHostInputs(cached, hostValidation)) {
+  if (!matchesUniversalHostInputs(cached, hostValidation, proof)) {
     return false;
   }
   const inputs = selectWatchInputs({

package/src/core/transform/validation/matchesUniversalHostInputTrees.ts

@@ -7,6 +7,7 @@ import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTrans
 import { resultFilesystem } from "../cache/resultFilesystem";
 import { pluginSourceHolds } from "../inputs/pluginSourceHolds";
 import { usesPreparedPluginBuildEnvironments } from "../inputs/preparePluginBuildEnvironments";
+import type { TtscGenerationProof } from "./TtscGenerationProof";
 import type { TtscHostInputValidation } from "./TtscHostInputValidation";
 import { trackerProvesInputUnchanged } from "./trackerProvesInputUnchanged";
 
@@ -41,20 +42,23 @@ import { trackerProvesInputUnchanged } from "./trackerProvesInputUnchanged";
  * @evidence contracts/common.md#meaningful-documentation Native paragraphs distinguish source notification, environment authority and metadata-qualified digest reuse before param tags.
  * @evidence contracts/portability.md#os-neutral-implementation Supported plugin-source APIs and capability-qualified native trackers own source/toolchain observation without OS-wide watcher assumptions.
  * @evidence contracts/performance.md#bound-retention-and-release-resources One environment witness per current manifest tree is replaced in place; no delivery history is retained.
- * @evidence contracts/performance.md#efficient-algorithms Each tree first pays the shared environment reader's variable-key construction and native dependency qualification. Qualified silent sources avoid enumeration; other trees enumerate and sort the selected file population, inspect metadata and hash source bytes whenever population, metadata or clock evidence cannot qualify reuse. The synchronous owner can also refresh native environment authority after a mismatch.
+ * @evidence contracts/performance.md#efficient-algorithms An exact-generation synchronous transaction supplies one current batched environment qualification; otherwise each tree pays the shared environment reader's variable-key construction and native dependency qualification. Qualified silent sources avoid enumeration; other trees enumerate and sort the selected file population, inspect metadata and hash source bytes whenever population, metadata or clock evidence cannot qualify reuse. The synchronous owner can also refresh native environment authority after a mismatch.
  * @evidence contracts/performance.md#reuse-equivalent-work Generation environment witnesses and the owning digest cache share prior proof only while source and toolchain identities remain valid.
  */
 export function matchesUniversalHostInputTrees(
   cached: TtscCachedProjectTransform,
   validation: TtscHostInputValidation,
+  proof?: TtscGenerationProof.Transaction,
 ): boolean {
   for (const [directory, digest] of validation.trees) {
     // Read before any proof, so the environment recorded below is one the
     // proof saw or older, never a newer one it did not prove.
     const prepared = usesPreparedPluginBuildEnvironments(cached.result);
     const environment = prepared
-      ? PluginBuildEnvironmentReadings.cached(directory)
-      : processPluginBuildEnvironment(directory);
+      ? proof?.cached === cached && proof.environments !== undefined
+        ? proof.environments.get(directory)
+        : PluginBuildEnvironmentReadings.cached(directory)
+      : processPluginBuildEnvironment(directory, false, cached.projectRoot);
     if (environment === undefined) return false;
     if (
       trackerProvesInputUnchanged(cached.hostInputMutationTracker, directory) &&
@@ -67,6 +71,7 @@ export function matchesUniversalHostInputTrees(
         digest,
         resultFilesystem(cached.result),
         prepared ? { environment } : undefined,
+        cached.projectRoot,
       )
     )
       return false;

package/src/core/transform/validation/matchesUniversalHostInputs.ts

@@ -1,4 +1,5 @@
 import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform";
+import type { TtscGenerationProof } from "./TtscGenerationProof";
 import type { TtscHostInputValidation } from "./TtscHostInputValidation";
 import { matchesUniversalHostInputEntries } from "./matchesUniversalHostInputEntries";
 import { matchesUniversalHostInputProbes } from "./matchesUniversalHostInputProbes";
@@ -29,13 +30,14 @@ import { trackerProvesInputUnchanged } from "./trackerProvesInputUnchanged";
  * @evidence contracts/portability.md#os-neutral-implementation Filesystem-aware validators use actual tracker delivery capability and exact lexical coverage rather than platform-wide assumptions.
  * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The coordinator borrows generation manifests and trackers without retaining a result or acquiring a handle.
  * @evidence contracts/performance.md#efficient-algorithms Every admission first replays all generation-owned typed config predicates; this mandatory cost includes native queries, file bytes or directory membership independently of watcher/epoch qualification.  The coverage scan stops at the first unproved input. Each coverage query checks overlapping unproven scopes and sampled events with native path comparisons; fallback adds unresolved bytes, native candidate probes and plugin tree enumeration. Mandatory environment qualification pays its owning dependency and environment-key costs on either route.
- * @evidence contracts/performance.md#reuse-equivalent-work Typed config predicate replay is not cached by this coordinator and remains mandatory even when the following existing shortcut shares other proof.  Shared manifests and qualified silent sources avoid repeated content reads only while the owning tree validator also proves unchanged build environment.
+ * @evidence contracts/performance.md#reuse-equivalent-work Typed config predicates remain mandatory on every delivery. An exact-generation synchronous transaction may share their current replay across nested validators, but no pass or notification shortcut authorizes a later delivery to skip them.  Shared manifests and qualified silent sources avoid repeated content reads only while the owning tree validator also proves unchanged build environment.
  */
 export function matchesUniversalHostInputs(
   cached: TtscCachedProjectTransform,
   validation: TtscHostInputValidation,
+  proof?: TtscGenerationProof.Transaction,
 ): boolean {
-  if (!nativeInputPredicatesHold(cached)) return false;
+  if (!nativeInputPredicatesHold(cached, proof)) return false;
   let notificationsProveAll = true;
   for (const input of validation.covered) {
     if (!trackerProvesInputUnchanged(cached.hostInputMutationTracker, input)) {
@@ -44,10 +46,10 @@ export function matchesUniversalHostInputs(
     }
   }
   if (notificationsProveAll)
-    return matchesUniversalHostInputTrees(cached, validation);
+    return matchesUniversalHostInputTrees(cached, validation, proof);
   return (
     matchesUniversalHostInputEntries(cached, validation) &&
     matchesUniversalHostInputProbes(cached, validation) &&
-    matchesUniversalHostInputTrees(cached, validation)
+    matchesUniversalHostInputTrees(cached, validation, proof)
   );
 }

package/src/core/transform/validation/nativeInputPredicatesHold.ts

@@ -1,9 +1,19 @@
 import path from "node:path";
+import type { ITtscCompilerTransformation } from "ttsc";
 
 import type { TtscCachedProjectTransform } from "../cache/TtscCachedProjectTransform";
 import { resultFilesystem } from "../cache/resultFilesystem";
 import { envelopeDerivation } from "../envelope/envelopeDerivation";
 import { nativeInputPredicateMatches } from "../inputs/nativeInputPredicateMatches";
+import type { TtscGenerationProof } from "./TtscGenerationProof";
+
+// Weakly owned by immutable observation membership, never by current verdict.
+// Keeping this separate from native path derivation also preserves the empty
+// predicate gate's promise to perform no native identity observations.
+const predicateInputs = new WeakMap<
+  object,
+  Array<[string, ITtscCompilerTransformation.IInputObservation]>
+>();
 
 /**
  * Validate every generation-owned native config predicate before cache reuse.
@@ -16,25 +26,37 @@ import { nativeInputPredicateMatches } from "../inputs/nativeInputPredicateMatch
  * @evidence contracts/common.md#prohibited-implementation-shortcuts Metadata and notification shortcuts cannot omit typed config predicates or repair an unstable producer witness.
  * @evidence contracts/common.md#meaningful-documentation The comment identifies generation ownership and the admission shortcuts that must retain this gate.
  * @evidence contracts/portability.md#os-neutral-implementation Relative names are resolved against the recorded project with the filesystem view's path dialect; native identity and encoding belong to the replay operation.
- * @evidence contracts/performance.md#efficient-algorithms The initial observation scan detects whether native replay is required without resolving a root or performing filesystem queries. Nonempty populations add a second linear traversal plus native replay and path-byte costs, stopping at the first refusal; empty and legacy-only populations require no replay context.
- * @evidenceExclude contracts/performance.md#reuse-equivalent-work This admission gate stores no separate cache and checks the recorded generation supplied by its caller.
- * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Per-call enumeration owns no handle or watcher; the cached envelope owns retained predicates.
+ * @evidence contracts/performance.md#efficient-algorithms Immutable observation membership is indexed once, including an empty population. Each new synchronous admission replays only indexed native predicates and stops at the first refusal; nested validators share its verdict without another scan or native query. Empty populations require no native replay context.
+ * @evidence contracts/performance.md#reuse-equivalent-work A weak observation index shares immutable membership. Current verdicts belong only to an exact-owner synchronous transaction, never the next delivery or an await.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The weak index follows immutable observation lifetime; synchronous verdicts and native queries acquire no handle or history.
  */
 export function nativeInputPredicatesHold(
   cached: TtscCachedProjectTransform,
+  proof?: TtscGenerationProof.Transaction,
 ): boolean {
   if (cached.result.type === "exception") return false;
-  const observations = cached.result.graph?.inputObservations ?? {};
-  if (
-    !Object.values(observations).some(
-      (observation) => (observation.nativePredicates?.length ?? 0) !== 0,
-    )
-  )
-    return true;
+  if (proof?.cached === cached && proof.nativePredicates !== undefined)
+    return proof.nativePredicates;
+  // Membership is immutable generation data. A positive native verdict is
+  // current observation: share it only with nested synchronous validators,
+  // never the next delivery, pass or await (#1714).
+  const finish = (matches: boolean): boolean => {
+    if (proof?.cached === cached) proof.nativePredicates = matches;
+    return matches;
+  };
+  const observations = cached.result.graph?.inputObservations;
+  if (observations === undefined) return finish(true);
+  let inputs = predicateInputs.get(observations);
+  if (inputs === undefined) {
+    inputs = Object.entries(observations).filter(
+      ([, observation]) => (observation.nativePredicates?.length ?? 0) !== 0,
+    );
+    predicateInputs.set(observations, inputs);
+  }
+  if (inputs.length === 0) return finish(true);
   const filesystem = resultFilesystem(cached.result);
   const identities = envelopeDerivation(cached).identityContext;
-  for (const [name, observation] of Object.entries(observations)) {
-    if ((observation.nativePredicates?.length ?? 0) === 0) continue;
+  for (const [name, observation] of inputs) {
     const file = (
       (filesystem.platform ?? process.platform) === "win32"
         ? path.win32
@@ -42,7 +64,7 @@ export function nativeInputPredicatesHold(
     ).resolve(cached.projectRoot, name);
     for (const predicate of observation.nativePredicates ?? [])
       if (!nativeInputPredicateMatches(file, predicate, filesystem, identities))
-        return false;
+        return finish(false);
   }
-  return true;
+  return finish(true);
 }

package/src/core/transform/validation/notificationsProveProgramUnchanged.ts

@@ -4,6 +4,7 @@ import { TRANSFORM_CLOCK_REFERENCE_DIRECTORIES } from "../clock/TRANSFORM_CLOCK_
 import { refreshFilesystemClockReference } from "../clock/refreshFilesystemClockReference";
 import { isProjectWalkPath } from "../project/isProjectWalkPath";
 import { notificationsProveMembership } from "../tracker/notificationsProveMembership";
+import type { TtscGenerationProof } from "./TtscGenerationProof";
 import { matchesUniversalHostInputs } from "./matchesUniversalHostInputs";
 
 /**
@@ -42,6 +43,7 @@ export function notificationsProveProgramUnchanged(
    * proof.
    */
   cached: TtscCachedProjectTransform,
+  proof?: TtscGenerationProof.Transaction,
 ): boolean {
   if (!notificationsProveMembership(cached)) return false;
   for (const tracker of [
@@ -88,5 +90,5 @@ export function notificationsProveProgramUnchanged(
     TRANSFORM_CLOCK_REFERENCE_DIRECTORIES.get(cached),
     resultFilesystem(cached.result),
   );
-  return matchesUniversalHostInputs(cached, cached.hostInputValidation);
+  return matchesUniversalHostInputs(cached, cached.hostInputValidation, proof);
 }

package/src/core/transform/watch/captureWatchInputBaseline.ts

@@ -15,6 +15,9 @@ import { captureWatchInputBaselines } from "./captureWatchInputBaselines";
  *   a recorded predicate. Unrequested listings are not enumerated.
  * @param options.nativePredicates Native version-one codec kinds requested by
  *   recorded inputs. Raw native listings are independent of compiler listings.
+ * @param options.projectRoot Project whose plugin cache records prove a plugin
+ *   tree, so a new process does not read its sources and SDK again
+ *   (samchon/ttsc#1725).
  * @evidence contracts/common.md#principled-implementation Two independently captured codec facts must agree before a baseline is returned; equality detects observed changes but cannot establish absence of intervening unobserved changes.
  * @evidence contracts/common.md#clear-and-simple-design The singleton delegates to the batch owner, which assembles codec facts and owns independent observations and failure handling.
  * @evidence contracts/common.md#prohibited-implementation-shortcuts Unavailable reads retain their explicit codec markers and predicates; a mismatch or escaping exception declines capture without supplying expected state or retrying until a desired answer appears.
@@ -33,6 +36,7 @@ export function captureWatchInputBaseline(
     nativePredicates?: readonly (keyof NonNullable<
       TtscWatchInputBaseline["nativePredicates"]
     >)[];
+    projectRoot?: string;
   } = {},
 ): TtscWatchInputBaseline | undefined {
   return captureWatchInputBaselines([file], filesystem, options).get(file);

package/src/core/transform/watch/captureWatchInputBaselines.ts

@@ -48,6 +48,8 @@ export function captureWatchInputBaselines(
     nativePredicates?: readonly (keyof NonNullable<
       TtscWatchInputBaseline["nativePredicates"]
     >)[];
+    /** Project whose plugin cache records prove a plugin tree (#1725). */
+    projectRoot?: string;
   } = {},
 ): Map<string, TtscWatchInputBaseline | undefined> {
   const selected = [...new Set(files)];
@@ -89,6 +91,8 @@ function capture(
     nativePredicates?: readonly (keyof NonNullable<
       TtscWatchInputBaseline["nativePredicates"]
     >)[];
+    /** Project whose plugin cache records prove a plugin tree (#1725). */
+    projectRoot?: string;
   },
 ): TtscWatchInputBaseline {
   const stat = compilerStatKind(file, filesystem);
@@ -141,6 +145,8 @@ function capture(
     identity: pathIdentityKey(file, identities),
     realpath: compilerInputRealpathObservation(file, filesystem),
     stat,
-    ...(options.tree === true ? { tree: pluginSourceState(file) } : {}),
+    ...(options.tree === true
+      ? { tree: pluginSourceState(file, undefined, options.projectRoot) }
+      : {}),
   };
 }

package/src/core/transform/watch/notifyWatchInputs.ts

@@ -64,6 +64,9 @@ export function notifyWatchInputs(
   // so no persistent cache may keep it.
   if (
     hooks.project !== undefined &&
+    // Common delivery already withdrew this host cache. Incomplete local
+    // output cannot write a record, so avoid a second withdrawal callback.
+    cached.freshDeliveryOnly !== true &&
     !notifyProjectRecord(
       hooks.project,
       cached,

package/src/core/transform/watch/watchInputEvidenceMatchesDisk.ts

@@ -20,7 +20,10 @@ import type { TtscWatchInputEvidence } from "./TtscWatchInputEvidence";
  * a graph input by its state hash and physical target; a host input by the host
  * bytes' hash. The root-file membership is a walk over many paths and never
  * stands for one, so its evidence matches nothing here; the record holds it
- * apart. Evidence without a state proves nothing and does not match.
+ * apart. Evidence without a state proves nothing and does not match. A plugin
+ * tree is proven through the plugin cache records of the project the caller
+ * names, so a new process does not read its sources and SDK again
+ * (samchon/ttsc#1725).
  *
  * @evidence contracts/common.md#principled-implementation Each codec replays its recorded meaning: complete predicates, graph hash plus physical target, raw host hash or plugin-tree state; membership and absent state cannot establish one-path agreement.
  * @evidence contracts/common.md#clear-and-simple-design Discriminant branches delegate each observation to the codec owner and expose one conservative boolean comparison.
@@ -35,12 +38,19 @@ export function watchInputEvidenceMatchesDisk(
   file: string,
   evidence: TtscWatchInputEvidence,
   filesystem: TtscTransformFilesystemOperations = DEFAULT_FILESYSTEM_OPERATIONS,
+  projectRoot?: string,
 ): boolean {
   const state = evidence.state;
   if (state === undefined || state.codec === "membership") return false;
   try {
     if (state.codec === "tree") {
-      return pluginSourceHolds(file, state.digest, filesystem);
+      return pluginSourceHolds(
+        file,
+        state.digest,
+        filesystem,
+        undefined,
+        projectRoot,
+      );
     }
     if (state.codec === "predicates") {
       return matchesGraphInputObservation(

package/src/core/turbopack/turbopack.ts

@@ -171,6 +171,7 @@ export function turbopack(
   }
   const hooks: TtscTransformHooks = {
     exactPath: true,
+    watching,
     ...(addDependency === undefined
       ? {}
       : {
@@ -186,7 +187,7 @@ export function turbopack(
             toolDirectory,
             // Turbopack takes no record outside its root, so a watching worker
             // refuses a module it could hand none (samchon/ttsc#1480).
-            watching: bridge !== undefined,
+            watching,
           },
         }),
     ...(bindings.markVolatile === undefined