@ontrails/warden 1.0.0-beta.45 → 1.0.0-beta.47

package/src/rules/retired-vocabulary.ts

@@ -62,6 +62,7 @@ export const governedVocabularySymbolRenameSchema = z.object({
   from: z.string().min(1),
   match: z.enum(governedVocabularySymbolRenameMatchModes).default('exact'),
   reviewDeclarationTypes: z.array(z.string().min(1)).default([]),
+  safety: z.enum(['safe', 'review']).optional(),
   to: z.string().min(1),
 });
 
@@ -743,6 +744,16 @@ export const governedVocabularyTransitions =
           reason:
             'Preserve transition regression fixtures and the intentional negative resolver assertion after the public route is retired.',
         },
+        {
+          paths: [
+            'apps/trails/src/__tests__/regrade.test.ts',
+            'packages/regrade/src/downstream/__tests__/ast-rewrite.test.ts',
+            'packages/regrade/src/downstream/__tests__/vocabulary.test.ts',
+          ],
+          pattern: '^@ontrails/warden/ast(?:\\.js|\\.utils|/utils)$',
+          reason:
+            'Preserve the adjacent package-route variants used by the authored Warden AST transition regression fixtures.',
+        },
       ],
       reviewForms: [],
       safeRewriteForms: {
@@ -829,6 +840,9 @@ export const governedVocabularyTransitions =
         'cliProjection',
         'cliProjectionSchema',
         'collectLibraryProjection',
+        'collectionExtensionProjectionForFileRenames',
+        'extensionProjection',
+        'filterProjectedTargetExtensions',
         'projectActivationEdge',
         'projectActivationSource',
         'projectActivationSourceDeclaration',
@@ -860,6 +874,11 @@ export const governedVocabularyTransitions =
         'projectTrailVersions',
         'projectVersionDetours',
         'projectVersionRuntimeRefs',
+        'projectVocabularyText',
+        'projected',
+        'projectedEvidence',
+        'projectedFileInScopeCount',
+        'projectedTargetPaths',
         'SchemaProjector',
         'deriveShippedSurfaceProjectionInventory',
         'deriveTrailCliCommandProjection',
@@ -1190,6 +1209,15 @@ export const governedVocabularyTransitions =
           from: 'collectLibraryProjection',
           to: 'deriveTopoGraphLibrary',
         },
+        {
+          from: 'collectionExtensionProjectionForFileRenames',
+          to: 'deriveCollectionExtensionsForFileRenames',
+        },
+        { from: 'extensionProjection', to: 'derivedExtensions' },
+        {
+          from: 'filterProjectedTargetExtensions',
+          to: 'filterDerivedTargetExtensions',
+        },
         { from: 'projectActivationEdge', to: 'deriveActivationEdge' },
         { from: 'projectActivationSource', to: 'deriveActivationSource' },
         {
@@ -1233,6 +1261,18 @@ export const governedVocabularyTransitions =
           from: 'projectVersionRuntimeRefs',
           to: 'deriveVersionRuntimeRefs',
         },
+        { from: 'projectVocabularyText', to: 'deriveVocabularyText' },
+        {
+          from: 'projected',
+          safety: 'review',
+          to: 'derived',
+        },
+        { from: 'projectedEvidence', to: 'derivedEvidence' },
+        {
+          from: 'projectedFileInScopeCount',
+          to: 'derivedFileInScopeCount',
+        },
+        { from: 'projectedTargetPaths', to: 'derivedTargetPaths' },
         { from: 'SchemaProjector', to: 'SchemaDeriver' },
         {
           from: 'deriveShippedSurfaceProjectionInventory',

package/src/rules/types.ts

@@ -386,22 +386,25 @@ export interface ProjectContext {
 export interface GovernedVocabularyHistoryEvidence {
   readonly caseSensitive: boolean;
   readonly id: string;
-  readonly latestFormObservations: readonly GovernedVocabularyHistoryFormObservation[];
+  readonly latestFormJudgments: readonly GovernedVocabularyHistoryFormJudgment[];
   readonly path: string;
   readonly provenance?: GovernedVocabularyHistoryProvenance;
   readonly runCount: number;
   readonly transitionId: string;
 }
 
-/** One vocabulary-form observation preserved in committed Regrade history. */
-export interface GovernedVocabularyHistoryFormObservation {
+/** One compact vocabulary-form judgment preserved in committed Regrade history. */
+export interface GovernedVocabularyHistoryFormJudgment {
   readonly disposition: string;
   readonly form: string;
-  readonly line: number;
-  readonly path: string;
-  readonly reason: string;
-  readonly scopeTier?: 'in-scope' | 'policy-classified' | undefined;
-  readonly verdict: 'applied' | 'deferred' | 'modified' | 'skipped';
+  readonly reason?: string | undefined;
+  readonly representative?:
+    | {
+        readonly line: number;
+        readonly path: string;
+      }
+    | undefined;
+  readonly target?: string | undefined;
 }
 
 export interface GovernedVocabularyHistoryIssue {

package/src/trails/schema.ts

@@ -119,21 +119,24 @@ export const authoredMcpSurfaceBindingSetSchema = z.object({
     .describe('Trail ids registered in the owning app topo'),
 });
 
-const governedVocabularyHistoryObservationSchema = z.object({
+const governedVocabularyHistoryFormJudgmentSchema = z.object({
   disposition: z.string(),
   form: z.string(),
-  line: z.number().int().positive(),
-  path: z.string(),
-  reason: z.string(),
-  scopeTier: z.enum(['in-scope', 'policy-classified']).optional(),
-  verdict: z.enum(['applied', 'deferred', 'modified', 'skipped']),
+  reason: z.string().optional(),
+  representative: z
+    .object({
+      line: z.number().int().positive(),
+      path: z.string(),
+    })
+    .optional(),
+  target: z.string().optional(),
 });
 
 const governedVocabularyHistoryEvidenceSchema = z.object({
   caseSensitive: z.boolean(),
   id: z.string(),
-  latestFormObservations: z
-    .array(governedVocabularyHistoryObservationSchema)
+  latestFormJudgments: z
+    .array(governedVocabularyHistoryFormJudgmentSchema)
     .readonly(),
   path: z.string(),
   runCount: z.number().int().nonnegative(),

package/src/workspaces.ts

@@ -2,10 +2,14 @@
  * Workspace-manifest discovery for Warden project-aware rules.
  */
 
-import { realpathSync } from 'node:fs';
-import { dirname, join, relative, resolve } from 'node:path';
+import { readFileSync, realpathSync } from 'node:fs';
+import { dirname, join, posix, relative, resolve } from 'node:path';
 
-import { listWorkspacePackages, matchesAnyPathGlob } from '@ontrails/core';
+import {
+  listWorkspacePackages,
+  listWorkspacePatterns,
+  matchesAnyPathGlob,
+} from '@ontrails/core';
 
 export interface WardenPublicWorkspace {
   readonly name: string;
@@ -18,6 +22,8 @@ export interface WardenPublicWorkspace {
 }
 
 export interface WardenWorkspaceCollectionOptions {
+  /** Root-relative package manifests observed by the owning source collection. */
+  readonly collectedPackageJsonPaths?: ReadonlySet<string> | undefined;
   readonly exclude?: readonly string[];
 }
 
@@ -27,6 +33,7 @@ interface PackageManifest {
   readonly files?: unknown;
   readonly name?: unknown;
   readonly private?: unknown;
+  readonly workspaces?: unknown;
 }
 
 const normalizePath = (path: string): string => path.replaceAll('\\', '/');
@@ -42,6 +49,60 @@ const normalizeRealPath = (path: string): string => {
 const rootRelativePath = (rootDir: string, path: string): string =>
   normalizePath(relative(rootDir, path));
 
+const readPackageManifest = (path: string): PackageManifest | undefined => {
+  try {
+    return JSON.parse(readFileSync(path, 'utf8')) as PackageManifest;
+  } catch {
+    return undefined;
+  }
+};
+
+const matchesWorkspacePattern = (
+  workspacePath: string,
+  pattern: string
+): boolean => {
+  const normalizedPattern = normalizePath(pattern).replace(/^\.\//, '');
+  return normalizedPattern.endsWith('/*')
+    ? posix.dirname(workspacePath) === normalizedPattern.slice(0, -2)
+    : workspacePath === normalizedPattern;
+};
+
+interface WorkspaceManifestCandidate {
+  readonly manifest: PackageManifest;
+  readonly packageJsonPath: string;
+}
+
+const collectedWorkspaceManifests = (
+  rootDir: string,
+  packageJsonPaths: ReadonlySet<string>
+): readonly WorkspaceManifestCandidate[] => {
+  if (!packageJsonPaths.has('package.json')) {
+    return [];
+  }
+  const rootManifest = readPackageManifest(join(rootDir, 'package.json'));
+  const patterns = listWorkspacePatterns(rootManifest);
+
+  return [...packageJsonPaths]
+    .filter((path) => path !== 'package.json' && path.endsWith('/package.json'))
+    .toSorted()
+    .flatMap((path): readonly WorkspaceManifestCandidate[] => {
+      const normalizedPath = normalizePath(path).replace(/^\.\//, '');
+      const workspacePath = posix.dirname(normalizedPath);
+      if (
+        posix.isAbsolute(normalizedPath) ||
+        normalizedPath.startsWith('../') ||
+        !patterns.some((pattern) =>
+          matchesWorkspacePattern(workspacePath, pattern)
+        )
+      ) {
+        return [];
+      }
+      const packageJsonPath = resolve(rootDir, normalizedPath);
+      const manifest = readPackageManifest(packageJsonPath);
+      return manifest ? [{ manifest, packageJsonPath }] : [];
+    });
+};
+
 const isRecord = (value: unknown): value is Record<string, unknown> =>
   Boolean(value && typeof value === 'object' && !Array.isArray(value));
 
@@ -172,10 +233,14 @@ export const collectPublicWorkspaces = (
 ): ReadonlyMap<string, WardenPublicWorkspace> => {
   const normalizedRoot = normalizeRealPath(rootDir);
   const workspaces = new Map<string, WardenPublicWorkspace>();
+  const candidates = options.collectedPackageJsonPaths
+    ? collectedWorkspaceManifests(
+        normalizedRoot,
+        options.collectedPackageJsonPaths
+      )
+    : listWorkspacePackages<PackageManifest>(normalizedRoot);
 
-  for (const workspacePackage of listWorkspacePackages<PackageManifest>(
-    normalizedRoot
-  )) {
+  for (const workspacePackage of candidates) {
     const workspace = publicWorkspaceFromManifest(
       workspacePackage.packageJsonPath,
       workspacePackage.manifest