ast-mcp-server 0.15.1 → 0.17.0

package/dist/services/operations.js

@@ -4,7 +4,11 @@ import { open, readFile, stat } from "node:fs/promises";
 import path from "node:path";
 import { createTwoFilesPatch } from "diff";
 import { LanguageVariant, Node, ScriptTarget, SyntaxKind, ts } from "ts-morph";
+import { isPipeClass } from "./angular-decorators.js";
+import { planTemplateEdits } from "./angular-template-rename.js";
 import { collectTemplateUsages } from "./angular-templates.js";
+import { checkTemplateTypes } from "./angular-template-typecheck.js";
+import { evaluateBlock } from "./operation-block-policy.js";
 import { findNonDeclarationReferences } from "./references.js";
 import { compareObservedDiagnostics, observeDiagnostic, } from "./diagnostics.js";
 import { probePublicationCapability, publishAuthenticated, removeOwnedPublicationEntry, rollbackOwnedCommit, snapshotHeldFile, } from "./authenticated-publication.js";
@@ -45,6 +49,7 @@ function planHashFor(operation, version = 2) {
         diagnostics: operation.diagnostics,
         allow_new_errors: operation.allow_new_errors,
         blocked: operation.blocked,
+        ...(version === 3 ? templateHashFields(operation) : {}),
         files: operation.files.map((file) => ({
             file: file.file,
             original_hash: file.originalHash,
@@ -53,6 +58,27 @@ function planHashFor(operation, version = 2) {
         })),
     }));
 }
+/** The version 3 additions, in a fixed key order so equal deltas always hash equal. */
+function templateHashFields(operation) {
+    const delta = operation.template_diagnostics;
+    if (delta === undefined || operation.block_on_template_errors === undefined) {
+        throw new Error("A version 3 plan requires template_diagnostics and block_on_template_errors.");
+    }
+    return {
+        template_diagnostics: {
+            status: delta.status,
+            ...(delta.status === "completed" ? {} : { reason: delta.reason }),
+            added: delta.added,
+            removed: delta.removed,
+            addedErrors: delta.addedErrors,
+        },
+        block_on_template_errors: operation.block_on_template_errors,
+    };
+}
+/** Plans without a template check keep hashing as version 2; only a check upgrades them. */
+function planVersionOf(operation) {
+    return operation.template_diagnostics === undefined ? 2 : 3;
+}
 function pruneOperations() {
     const now = operationNow();
     for (const [id, operation] of operations) {
@@ -214,8 +240,22 @@ async function planAuxiliaryFiles(edits, projectRoot, snapshotFiles, requestCont
     }
     return planned;
 }
+/** Maps the planned files to the check input; paths are relative to the tsconfig directory. */
+function templateCheckInput(tsConfigFilePath, files, auxiliaryFiles) {
+    const base = path.dirname(tsConfigFilePath);
+    return {
+        tsConfigFilePath,
+        templates: auxiliaryFiles.map((file) => file.absolutePath),
+        overlay: files.map((file) => ({ absolutePath: file.absolutePath, text: file.updatedText })),
+        changes: files.map((file) => ({
+            file: path.relative(base, file.absolutePath),
+            beforeText: isCreatedFile(file) ? null : file.originalText,
+            afterText: file.updatedText,
+        })),
+    };
+}
 /** Internal seam shared by the prepare functions; exported so tests can drive `mutate` directly. */
-export async function createPlan(projectRootInput, kind, allowNewErrors, mutate, requestContext) {
+export async function createPlan(projectRootInput, kind, allowNewErrors, mutate, requestContext, planOptions = {}) {
     requestContext.checkpoint();
     let retainedOperationId;
     return withProjectOperation(projectRootInput, async (operationContext) => {
@@ -314,13 +354,25 @@ export async function createPlan(projectRootInput, kind, allowNewErrors, mutate,
             postWorkspaceFiles.set(file.absolutePath, file.updatedHash);
         }
         const postWorkspaceHash = hashWorkspaceFiles(postWorkspaceFiles);
+        // Only a rename that edits templates is checked; the check runs inside the project lock and
+        // before the digest check below, which proves the child's disk reads saw an unchanged tree.
+        const templateDiagnostics = kind === "rename_symbol" && auxiliaryFiles.length > 0
+            ? await checkTemplateTypes(templateCheckInput(context.tsConfigFilePath, files, auxiliaryFiles), operationContext)
+            : undefined;
+        operationContext.checkpoint();
         const workspaceAfter = createWorkspaceSnapshot(createFreshProject(context.tsConfigFilePath));
         operationContext.checkpoint();
         if (workspaceAfter.digest !== workspaceBefore.digest) {
             throw new Error("Workspace changed while the operation was being prepared. Retry preparation.");
         }
         const fullPreview = files.map((file) => file.diff).join("\n");
-        const blocked = !allowNewErrors && diagnosticDelta.addedErrors.length > 0;
+        const blockOnTemplateErrors = planOptions.blockOnTemplateErrors ?? false;
+        const verdict = evaluateBlock({
+            allowNewErrors,
+            typescriptErrors: diagnosticDelta.addedErrors.length,
+            template: templateDiagnostics,
+            blockOnTemplateErrors,
+        });
         const now = operationNow();
         const operationId = randomUUID();
         const recordWithoutHash = {
@@ -342,17 +394,21 @@ export async function createPlan(projectRootInput, kind, allowNewErrors, mutate,
             workspace_file_count: workspaceBefore.fileCount,
             diagnostics: diagnosticDelta,
             allow_new_errors: allowNewErrors,
-            blocked,
-            block_reason: blocked
-                ? `${diagnosticDelta.addedErrors.length} new TypeScript error(s) would be introduced. Prepare again with allow_new_errors=true only after explicit review.`
-                : null,
+            blocked: verdict.blocked,
+            block_reason: verdict.reason,
             preview: fullPreview.length <= MAX_INLINE_PREVIEW_CHARS ? fullPreview : null,
             preview_truncated: fullPreview.length > MAX_INLINE_PREVIEW_CHARS,
+            ...(templateDiagnostics === undefined
+                ? {}
+                : {
+                    template_diagnostics: templateDiagnostics,
+                    block_on_template_errors: blockOnTemplateErrors,
+                }),
             files,
         };
         const record = {
             ...recordWithoutHash,
-            plan_hash: planHashFor(recordWithoutHash),
+            plan_hash: planHashFor(recordWithoutHash, planVersionOf(recordWithoutHash)),
         };
         operationContext.checkpoint();
         operations.set(operationId, record);
@@ -386,12 +442,18 @@ function publicOperation(record) {
         block_reason: record.block_reason,
         preview: record.preview,
         preview_truncated: record.preview_truncated,
+        ...(record.template_diagnostics === undefined
+            ? {}
+            : {
+                template_diagnostics: record.template_diagnostics,
+                block_on_template_errors: record.block_on_template_errors,
+            }),
     };
 }
 const TEMPLATE_ANY_CAST = "$any";
 /** Fails closed before any edit when template evidence is incomplete or the new name would be captured. */
-function assertTemplateRenameAllowed(coverageStatus, usages, newName) {
-    if (coverageStatus === "unfinished" || coverageStatus === "unsupported") {
+function assertTemplateRenameAllowed(coverageStatus, usages, newName, renameBlocked = false) {
+    if (renameBlocked || coverageStatus === "unfinished" || coverageStatus === "unsupported") {
         throw new PublicOperationalError("INCOMPLETE_EVIDENCE", "Template coverage is incomplete, so the rename cannot be proven safe.");
     }
     if (usages.some((usage) => usage.container === "inline")) {
@@ -417,24 +479,36 @@ export async function prepareRename(args, requestContext = NO_REQUEST_CONTEXT) {
         if (!Node.isRenameable(node)) {
             throw new Error(`Symbol "${args.symbolPath}" (${node.getKindName()}) does not support structural rename.`);
         }
+        // Templates bind a pipe by its `name` literal, never by class, so a class rename has no
+        // template edit and needs no template evidence.
+        const pipeClass = Node.isClassDeclaration(node) && isPipeClass(node);
         // Template usages must be collected before the rename mutates the program.
-        const { coverage, usages } = await collectTemplateUsages(node, context, rc);
-        assertTemplateRenameAllowed(coverage.status, usages, args.newName);
+        const { coverage, usages, renameBlocked } = pipeClass
+            ? {
+                coverage: { status: "not_applicable" },
+                usages: [],
+                renameBlocked: false,
+            }
+            : await collectTemplateUsages(node, context, rc);
+        assertTemplateRenameAllowed(coverage.status, usages, args.newName, renameBlocked);
+        const edits = coverage.status === "completed" || usages.length > 0
+            ? planTemplateEdits(node, usages, args.newName, context)
+            : [];
         const tsReferenceCount = Node.isReferenceFindable(node)
             ? findNonDeclarationReferences(node).length
             : 0;
         node.rename(args.newName);
         return {
-            referenceCount: tsReferenceCount + usages.length,
-            auxiliaryEdits: usages.map((usage) => ({
+            referenceCount: tsReferenceCount + edits.length,
+            auxiliaryEdits: edits.map(({ usage, newText }) => ({
                 absolutePath: usage.absolutePath,
                 start: usage.start,
                 end: usage.end,
-                newText: args.newName,
+                newText,
                 expectedHash: usage.fileHash,
             })),
         };
-    }, requestContext);
+    }, requestContext, { blockOnTemplateErrors: args.blockOnTemplateErrors });
 }
 export async function prepareReplaceBody(args, requestContext = NO_REQUEST_CONTEXT) {
     return createPlan(args.projectRoot, "replace_symbol_body", args.allowNewErrors ?? false, async ({ project }) => {
@@ -968,7 +1042,7 @@ export function exportOperationRecord(operationId) {
         })),
     };
 }
-export function importOperationRecord(persisted, expectedPlanHash, planVersion = 2) {
+export function importOperationRecord(persisted, expectedPlanHash, planVersion = planVersionOf(persisted)) {
     if (persisted.plan_hash !== expectedPlanHash) {
         throw new Error(`Plan hash mismatch for operation "${persisted.operation_id}". No files were written.`);
     }
@@ -1033,18 +1107,31 @@ export function importOperationRecord(persisted, expectedPlanHash, planVersion =
     if (JSON.stringify(addedErrors) !== JSON.stringify(persisted.diagnostics.addedErrors)) {
         throw new Error("Persisted diagnostic error delta is inconsistent.");
     }
-    const blocked = !persisted.allow_new_errors && addedErrors.length > 0;
-    if (persisted.blocked !== blocked) {
+    const templateDelta = persisted.template_diagnostics;
+    if (templateDelta !== undefined) {
+        const templateErrors = templateDelta.added.filter((diagnostic) => diagnostic.category === "Error");
+        if (JSON.stringify(templateErrors) !== JSON.stringify(templateDelta.addedErrors)) {
+            throw new Error("Persisted template diagnostic error delta is inconsistent.");
+        }
+    }
+    if ((planVersion === 3) !== (templateDelta !== undefined)) {
+        throw new Error("Persisted template diagnostics are inconsistent with the plan version.");
+    }
+    const verdict = evaluateBlock({
+        allowNewErrors: persisted.allow_new_errors,
+        typescriptErrors: addedErrors.length,
+        template: templateDelta,
+        blockOnTemplateErrors: persisted.block_on_template_errors ?? false,
+    });
+    if (persisted.blocked !== verdict.blocked) {
         throw new Error("Persisted blocked status is inconsistent with diagnostics policy.");
     }
     const fullPreview = files.map((file) => file.diff).join("\n");
     const record = {
         ...persisted,
         affected_files: affectedFiles,
-        blocked,
-        block_reason: blocked
-            ? `${addedErrors.length} new TypeScript error(s) would be introduced. Prepare again with allow_new_errors=true only after explicit review.`
-            : null,
+        blocked: verdict.blocked,
+        block_reason: verdict.reason,
         preview: fullPreview.length <= MAX_INLINE_PREVIEW_CHARS ? fullPreview : null,
         preview_truncated: fullPreview.length > MAX_INLINE_PREVIEW_CHARS,
         tsConfigFilePath: context.tsConfigFilePath,

package/dist/services/project-operation-scheduler.js

@@ -354,6 +354,10 @@ export class ProjectOperationScheduler {
             checkpoint: () => {
                 this.#checkpoint(node);
             },
+            remainingMs: () => {
+                const startedAt = node.executionStartedAt ?? this.#readNow();
+                return Math.max(0, this.#operationDeadlineMs - (this.#readNow() - startedAt));
+            },
             markExecuting: () => {
                 this.#checkpoint(node);
                 if (node.phase !== "synchronizing") {

package/dist/tools/find_references.js

@@ -41,6 +41,7 @@ const TemplateCoverageSchema = z.object({
         "size_exceeded",
         "work_exhausted",
         "inherited_member",
+        "cross_component",
     ])
         .optional(),
     templates: z.number().int().min(0).optional(),
@@ -68,7 +69,7 @@ const ReferenceOutputSchemas = {
 export function registerFindReferences(server) {
     server.registerTool(TOOL_NAME, {
         title: "Find semantic symbol references",
-        description: "Finds type-resolved references and returns bounded project-relative locations, including declaration impact by default. When @angular/compiler resolves, it also reports Angular template usages tagged by origin with a template_coverage verdict; incomplete coverage does not prove absence, and template errors are not diagnosed.",
+        description: "Finds type-resolved references and returns bounded project-relative locations, including declaration impact by default. When @angular/compiler resolves, it also reports Angular template usages, including consumer templates, tagged by origin with a template_coverage verdict; completed covers templates inside the Project only, incomplete coverage does not prove absence. It reports usages only; template type errors are reported by ast_rename_symbol plans in template_diagnostics.",
         inputSchema: AstFindReferencesInputSchema,
         annotations: {
             readOnlyHint: true,

package/dist/tools/operation-schema.js

@@ -34,6 +34,46 @@ export const PreparedOperationOutputSchema = z.object({
     preview: z.string().nullable(),
     preview_truncated: z.boolean(),
 });
+const TemplateDiagnosticsListSchema = z.array(NormalizedDiagnosticSchema);
+const NonCompletedTemplateListSchema = z.array(NormalizedDiagnosticSchema).max(0);
+/** Template type-check delta of a rename; present only when the check ran or tried to. */
+export const TemplateDiagnosticsSchema = z.discriminatedUnion("status", [
+    z
+        .object({
+        status: z.literal("completed"),
+        added: TemplateDiagnosticsListSchema,
+        removed: TemplateDiagnosticsListSchema,
+        added_errors: TemplateDiagnosticsListSchema,
+    })
+        .strict(),
+    z
+        .object({
+        status: z.enum(["unavailable", "unfinished"]),
+        reason: z.enum([
+            "compiler_cli_missing",
+            "compiler_unsupported",
+            "typescript_incompatible",
+            "work_exhausted",
+            "deadline",
+            "check_failed",
+        ]),
+        added: NonCompletedTemplateListSchema,
+        removed: NonCompletedTemplateListSchema,
+        added_errors: NonCompletedTemplateListSchema,
+    })
+        .strict(),
+]);
+/** Only `ast_rename_symbol` can carry template diagnostics, so only its contract changes. */
+export const RenameOperationOutputSchema = PreparedOperationOutputSchema.extend({
+    template_diagnostics: TemplateDiagnosticsSchema.optional(),
+});
+/** The one place that turns the record shape (`addedErrors`) into the wire shape. */
+export function toTemplateDiagnosticsOutput(delta) {
+    const lists = { added: delta.added, removed: delta.removed, added_errors: delta.addedErrors };
+    return delta.status === "completed"
+        ? { status: "completed", ...lists }
+        : { status: delta.status, reason: delta.reason, ...lists };
+}
 export function serializePreparedOperation(operation) {
     if (operation.status !== "prepared") {
         throw new Error(`Operation ${operation.operation_id} is not in prepared state.`);
@@ -60,5 +100,8 @@ export function serializePreparedOperation(operation) {
         block_reason: operation.block_reason,
         preview: operation.preview,
         preview_truncated: operation.preview_truncated,
+        ...(operation.template_diagnostics === undefined
+            ? {}
+            : { template_diagnostics: toTemplateDiagnosticsOutput(operation.template_diagnostics) }),
     };
 }

package/dist/tools/rename_symbol.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { prepareRename } from "../services/operations.js";
 import { createRequestContext } from "../services/request-context.js";
-import { PreparedOperationOutputSchema, serializePreparedOperation } from "./operation-schema.js";
+import { RenameOperationOutputSchema, serializePreparedOperation } from "./operation-schema.js";
 import { createToolErrorContext, errorResult, structuredResult } from "./result.js";
 const TOOL_NAME = "ast_rename_symbol";
 const AstRenameSymbolInputSchema = z.object({
@@ -17,20 +17,24 @@ const AstRenameSymbolInputSchema = z.object({
         .boolean()
         .default(false)
         .describe("Permit a plan with new TypeScript errors after explicit review."),
+    block_on_template_errors: z
+        .boolean()
+        .default(false)
+        .describe("Block the plan when a completed template check adds template errors. allow_new_errors still waives it."),
 });
 export function registerRenameSymbol(server) {
     server.registerTool(TOOL_NAME, {
         title: "Prepare a project-wide structural rename",
-        description: "Prepares an exact hash-bound rename plan without writing. Review the preview and apply its operation_id with ast_apply_operation. The plan also rewrites external Angular templates hash-bound to the workspace snapshot; diagnostics stay TypeScript-only.",
+        description: "Prepares an exact hash-bound rename plan without writing. Review the preview and apply its operation_id with ast_apply_operation. The plan also rewrites external Angular templates, including consumer templates when coverage is completed, hash-bound to the workspace snapshot. The diagnostics field stays TypeScript-only; when templates are edited, template_diagnostics reports the template type-check delta separately with a typed status, and blocks only with block_on_template_errors=true.",
         inputSchema: AstRenameSymbolInputSchema,
-        outputSchema: PreparedOperationOutputSchema,
+        outputSchema: RenameOperationOutputSchema,
         annotations: {
             readOnlyHint: true,
             destructiveHint: false,
             idempotentHint: false,
             openWorldHint: false,
         },
-    }, async ({ project_root, file_path, symbol_path, new_name, dry_run, allow_new_errors }, extra) => {
+    }, async ({ project_root, file_path, symbol_path, new_name, dry_run, allow_new_errors, block_on_template_errors, }, extra) => {
         const requestContext = createRequestContext(extra.signal);
         try {
             if (!dry_run) {
@@ -42,6 +46,7 @@ export function registerRenameSymbol(server) {
                 symbolPath: symbol_path,
                 newName: new_name,
                 allowNewErrors: allow_new_errors,
+                blockOnTemplateErrors: block_on_template_errors,
             }, requestContext);
             return structuredResult(serializePreparedOperation(operation));
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ast-mcp-server",
-  "version": "0.15.1",
+  "version": "0.17.0",
   "description": "Structural code MCP server and batch CLI for compact TypeScript/JavaScript reads and hash-bound AST edits.",
   "keywords": [
     "mcp",
@@ -26,6 +26,9 @@
   },
   "type": "module",
   "packageManager": "yarn@4.15.0",
+  "workspaces": [
+    "test/angular-matrix/*"
+  ],
   "dsh": {
     "bundle": {
       "patch": "./cordis.patch.yml"
@@ -65,12 +68,14 @@
     "hono": "4.13.13",
     "minimatch": "11.0.3",
     "nanoid": "3.3.18",
-    "qs": "6.16.1"
+    "qs": "6.16.1",
+    "@babel/core@npm:7.25.2": "npm:7.29.7",
+    "@babel/core@npm:7.26.9": "npm:7.29.7"
   },
   "scripts": {
     "build": "tsc",
     "typecheck": "tsc --noEmit && tsc -p tsconfig.test.json",
-    "test": "vitest run --exclude test/supervised-worker.integration.test.ts && yarn build && vitest run test/supervised-worker.integration.test.ts --no-file-parallelism",
+    "test": "vitest run --exclude test/supervised-worker.integration.test.ts --exclude test/angular-template-typecheck.integration.test.ts --exclude test/operations-template-typecheck.integration.test.ts && yarn build && vitest run test/supervised-worker.integration.test.ts test/angular-template-typecheck.integration.test.ts test/operations-template-typecheck.integration.test.ts --no-file-parallelism",
     "test:watch": "vitest",
     "test:mcp": "yarn build && node scripts/mcp-smoke.mjs",
     "test:lifecycle": "yarn build && node scripts/mcp-lifecycle-smoke.mjs",
@@ -135,5 +140,5 @@
     "vitest": "^5.0.5",
     "yaml": "^2.9.0"
   },
-  "gitHead": "20548017b7c9266160963a0272ce8757b8f42a77"
+  "gitHead": "e49987bd1fd36432aa76ecb27ca8359eedb613ad"
 }

package/skills/structural-code-editing/SKILL.md

@@ -4,7 +4,7 @@ description: "Trigger: navegar, analizar o editar TypeScript/JavaScript con el c
 license: "ISC"
 metadata:
   author: "yail"
-  version: "4.6.0"
+  version: "4.8.0"
   hermes:
     tags: ["typescript", "javascript", "ast", "refactoring", "mcp"]
     homepage: "https://github.com/yailPeralta/ast-mcp-server"
@@ -45,16 +45,22 @@ For each dimension, `groups.length + omitted_group_count = total_group_count` an
 
 ## Angular templates
 
-In an Angular project (`@angular/core` resolvable from the tsconfig directory), `ast_find_references` also reports usages of a component member inside its external `templateUrl` template and inline `template`. Each item carries `origin` (`compiler`, `template_external` or `template_inline`), and the response adds `template_coverage` and `template_reference_count`. `reference_count` stays TypeScript-only; `total` counts both kinds.
+In an Angular project (`@angular/core` resolvable from the tsconfig directory), `ast_find_references` also reports usages of a component member inside its external `templateUrl` template and inline `template`, and binding usages in consumer templates. Each item carries `origin` (`compiler`, `template_external` or `template_inline`), and the response adds `template_coverage` and `template_reference_count`. `reference_count` stays TypeScript-only; `total` counts both kinds.
 
-Read `template_coverage` before inferring absence. Only `completed` proves every template of the declaring component was examined. `unfinished` (for example `compiler_missing`, `compiler_unsupported`, `template_unresolved`, `template_parse_error`, `size_exceeded`) and `unsupported` (for example an inherited member) never prove that no template usage exists. `not_applicable` means the feature is off and the response is unchanged.
+Read `template_coverage` before inferring absence. Only `completed` proves every template it covers was examined. `unfinished` (for example `compiler_missing`, `compiler_unsupported`, `template_unresolved`, `template_parse_error`, `size_exceeded`, `cross_component`, `work_exhausted`) and `unsupported` (for example an inherited member) never prove that no template usage exists. `not_applicable` means the feature is off and the response is unchanged.
 
-`ast_rename_symbol` updates external templates in the same reviewed plan and rewrites them only through `ast_apply_operation`. It fails closed: coverage `unfinished` or `unsupported` returns `INCOMPLETE_EVIDENCE`, and an inline template usage, a new name that collides with a template local, or `$any` returns `MUTATION_BLOCKED`. Pipe names, `#ref`/`let-` targets, child inputs and outputs, host bindings and `styleUrls` are not renamed. Apply is sequential, not globally atomic; rollback restores the owned templates.
+Consumer templates: for a member bound through the selector (`@Input`, `@Output`, `input()`, `output()`, `model()`, a literal alias, or a literal entry of the `inputs` / `outputs` metadata), the binding keys `[x]`, `x="lit"`, `[(x)]`, `(y)` and `(xChange)` are listed with kinds `TemplateInputBinding` for `[x]`, `TemplateAttribute` for `x="lit"`, `TemplateTwoWayBinding` for `[(x)]` and `TemplateOutputBinding` for `(y)` and `(xChange)` in the templates of components whose resolved scope contains the declaring component (literal standalone `imports`, or NgModule `declarations` plus the `exports` of imported modules). For a `@Pipe` class with a literal `name`, and for its `transform` member, `| name` usages in in-scope templates are listed with kind `TemplatePipeName`. A same selector or pipe name outside that scope is ignored.
+
+For these members, `completed` means template evidence inside the Project only: every component template of the Project (the tsconfig passed as `project_root`) was read and every match resolved. `hostDirectives`, `@Directive` inputs and outputs, and non-literal scopes, aliases, metadata or pipe names stay `unfinished` with `cross_component`. Runtime bindings (`setInput`, router input binding, `createComponent` and other dynamic component APIs) and consumers outside the Project (other tsconfigs, libraries, other applications) are never examined, so `completed` does not cover them.
+
+`ast_rename_symbol` updates the declaring component's external templates and, for a selector-bound member with `completed` coverage, every external consumer template in the same reviewed plan; it rewrites them only through `ast_apply_operation`. Consumer rewrites keep `[`, `(`, `[(`, `bind-`, `on-`, `bindon-` and the values, a `model()` event key becomes `<name>Change`, and alias-keyed bindings stay. It fails closed: coverage `unfinished` or `unsupported`, `hostDirectives`, `@Directive` members, non-literal aliases and members listed in `inputs` / `outputs` metadata return `INCOMPLETE_EVIDENCE`. An inline template usage (own or consumer), `[(x)]` on a non-`model()` pair, a new name that collides with a template local, another input, output or alias of the directive (or its `Change` name) or a binding of another directive on the same element, `$any`, or a name in the directive's selector return `MUTATION_BLOCKED`. `#ref`/`let-` targets, host bindings and `styleUrls` are not renamed. Apply is sequential, not globally atomic; rollback restores the owned and consumer templates.
+
+Pipes: renaming a `@Pipe` class applies with TypeScript edits only; the `name` literal and every `| name` usage stay unchanged. Renaming its `transform` member returns `INCOMPLETE_EVIDENCE`.
 
 Limits to state when reporting:
 
 - `ast_explore` is TypeScript-only: its references omit template usages. This is tracked in issue #380. Use `ast_find_references` for template evidence; rename still blocks independently.
-- Diagnostics stay TypeScript-only: `ast_get_diagnostics` and the post-apply delta do not detect template errors. A template-only breakage produces no diagnostic, so run the project's Angular build or tests after a rename.
+- The `diagnostics` field stays TypeScript-only. When a rename edits a template, the plan also carries `template_diagnostics`, a best-effort template type-check delta (`status`, `reason`, `added`, `removed`, `added_errors`) from the project's own `@angular/compiler-cli`; it is absent for non-Angular projects and for renames that edit no template. `completed` is the only status with data; `unavailable` (`compiler_cli_missing`, `compiler_unsupported`, `typescript_incompatible`) and `unfinished` (`work_exhausted`, `deadline`, `check_failed`) mean unknown, so run the project's build or tests before applying. `block_on_template_errors` (default `false`) blocks only a `completed` delta with `added_errors`, and `allow_new_errors` waives it. `template_diagnostics[].file` is relative to the directory of the tsconfig, while `diagnostics[].file` is relative to `project_root`. `@angular/compiler-cli` is not a declared peer and must resolve from the project, otherwise the status is `unavailable/compiler_cli_missing`. Template-editing renames persist as plan schema v3, which is rejected on import after a downgrade.
 - Detection uses the user's own `@angular/compiler`, never a bundled one. It is an optional peer (`>=18.0.0 <23.0.0`) that the project already installs with Angular. If it is missing or out of range, coverage is `unfinished` and rename is blocked. Yarn PnP projects without `node_modules` resolve nothing and report `unfinished`.
 
 ## Contributor contract

package/skills/structural-code-editing/references/operations.md

@@ -22,9 +22,11 @@ Preferir `file_path` relativo; un suffix ambiguo debe devolver candidatos. `ast_
 
 ### Angular templates
 
-`ast_find_references` adds template usages (`origin: "template_external" | "template_inline"`, `template_coverage`, `template_reference_count`) only when `@angular/core` resolves; otherwise the response is unchanged. Treat `template_coverage.status` other than `completed` as not proving absence. `ast_explore` is TypeScript-only for references (tracked in issue #380), and diagnostics stay TypeScript-only, so template errors are never detected.
+`ast_find_references` adds template usages (`origin: "template_external" | "template_inline"`, `template_coverage`, `template_reference_count`) only when `@angular/core` resolves; otherwise the response is unchanged. Treat `template_coverage.status` other than `completed` as not proving absence. Selector-bound members (`@Input`, `@Output`, `input()`, `output()`, `model()`, literal aliases, literal `inputs` / `outputs` metadata) also list their bindings in consumer templates (kinds `TemplateInputBinding` for `[x]`, `TemplateAttribute` for `x="lit"`, `TemplateTwoWayBinding` for `[(x)]` and `TemplateOutputBinding` for `(y)` and `(xChange)`), and `@Pipe` classes and their `transform` list `| name` usages (kind `TemplatePipeName`), for components whose resolved standalone or NgModule scope contains the declaring class. For them, `completed` covers templates inside the Project only. `hostDirectives`, `@Directive` inputs and outputs, and non-literal scopes, aliases or names stay `unfinished` with `cross_component`; runtime bindings (`setInput`, router input binding, `createComponent`) and consumers outside the Project are never examined. `ast_explore` is TypeScript-only for references (tracked in issue #380).
 
-`ast_rename_symbol` edits external templates and returns `INCOMPLETE_EVIDENCE` (coverage `unfinished` or `unsupported`) or `MUTATION_BLOCKED` (inline usage, template-local collision, `$any`). The user's `@angular/compiler` is an optional peer, never bundled; Yarn PnP projects without `node_modules` report `unfinished`. See the Angular templates section of `SKILL.md`.
+The `diagnostics` field stays TypeScript-only. When a rename edits a template, the plan also carries `template_diagnostics`, a best-effort template type-check delta (`status`, `reason`, `added`, `removed`, `added_errors`) from the project's own `@angular/compiler-cli`; it is absent for non-Angular projects and for renames that edit no template. `completed` is the only status with data; `unavailable` (`compiler_cli_missing`, `compiler_unsupported`, `typescript_incompatible`) and `unfinished` (`work_exhausted`, `deadline`, `check_failed`) mean unknown, so run the project's build or tests before applying. `block_on_template_errors` (default `false`) blocks only a `completed` delta with `added_errors`, and `allow_new_errors` waives it. `template_diagnostics[].file` is relative to the directory of the tsconfig, while `diagnostics[].file` is relative to `project_root`. `@angular/compiler-cli` is not a declared peer and must resolve from the project, otherwise the status is `unavailable/compiler_cli_missing`. Template-editing renames persist as plan schema v3, which is rejected on import after a downgrade.
+
+`ast_rename_symbol` edits external templates, including consumer templates of a selector-bound member with `completed` coverage, and returns `INCOMPLETE_EVIDENCE` (coverage `unfinished` or `unsupported`, `hostDirectives`, `@Directive` members, metadata-listed members, non-literal aliases) or `MUTATION_BLOCKED` (inline usage, template-local or binding-name collision, `[(x)]` on a non-`model()` pair, `$any`, name in the selector). Renaming a `@Pipe` class applies TypeScript edits only and keeps the `name` literal and `| name` usages; renaming `transform` returns `INCOMPLETE_EVIDENCE`. The user's `@angular/compiler` is an optional peer, never bundled; Yarn PnP projects without `node_modules` report `unfinished`. See the Angular templates section of `SKILL.md`.
 
 ## Trust, freshness y ausencia
 

package/skills/structural-code-editing/releases.json

@@ -2,15 +2,15 @@
   "schema_version": 2,
   "algorithm": "sha256",
   "current": {
-    "version": "4.6.0",
+    "version": "4.8.0",
     "files": [
       {
         "path": "SKILL.md",
-        "sha256": "afd054a923d9a4f825066e5c3fd2dfa7ae2269a8464819b032a5fbf19a9b14fd"
+        "sha256": "15e5d25553a3ebce86365ff7b43ed61e7df11dd6ad658e83ec6e43cd84118762"
       },
       {
         "path": "references/operations.md",
-        "sha256": "ee5dd8138b4f4570ee256c820c69b94d650a3d454119fff80b1dc08a6297b380"
+        "sha256": "dd633a24e9aabeb1d9e9d1f93e261906e7b30eb721fadfb3d317d6acc60db2ca"
       }
     ]
   },
@@ -82,23 +82,129 @@
     },
     {
       "version": "4.5.0",
-      "sha256": "be757e8bd98733c7ee952d63a2805dcd9877becf651b4fcb6ab63d20f6546f21",
+      "files": [
+        {
+          "path": "SKILL.md",
+          "sha256": "be757e8bd98733c7ee952d63a2805dcd9877becf651b4fcb6ab63d20f6546f21"
+        },
+        {
+          "path": "references/operations.md",
+          "sha256": "d52f01637e33e65ce523d19a810ce9488ab92228809768ec66a584120c24ad98"
+        }
+      ],
       "npm_versions": ["0.11.0"]
     },
     {
       "version": "4.5.0",
-      "sha256": "2729b30ff6b7344e6680c7ee02ab540bc6db9774ad7111f091cd356f8cc9d4ce",
+      "files": [
+        {
+          "path": "SKILL.md",
+          "sha256": "2729b30ff6b7344e6680c7ee02ab540bc6db9774ad7111f091cd356f8cc9d4ce"
+        },
+        {
+          "path": "references/operations.md",
+          "sha256": "d52f01637e33e65ce523d19a810ce9488ab92228809768ec66a584120c24ad98"
+        }
+      ],
       "npm_versions": ["0.11.1"]
     },
     {
       "version": "4.5.0",
-      "sha256": "18132b4b747d135e4ccfbca9e2190a9afb41e144cc06c31c5e6bc0f1571e11da",
+      "files": [
+        {
+          "path": "SKILL.md",
+          "sha256": "18132b4b747d135e4ccfbca9e2190a9afb41e144cc06c31c5e6bc0f1571e11da"
+        },
+        {
+          "path": "references/operations.md",
+          "sha256": "d52f01637e33e65ce523d19a810ce9488ab92228809768ec66a584120c24ad98"
+        }
+      ],
       "npm_versions": ["0.11.2"]
     },
     {
       "version": "4.6.0",
-      "sha256": "d0048ffd9a585d00791540c6fa5e0bec91ff95b1448479678f85702e6b09be8a",
+      "files": [
+        {
+          "path": "SKILL.md",
+          "sha256": "d0048ffd9a585d00791540c6fa5e0bec91ff95b1448479678f85702e6b09be8a"
+        },
+        {
+          "path": "references/operations.md",
+          "sha256": "d52f01637e33e65ce523d19a810ce9488ab92228809768ec66a584120c24ad98"
+        }
+      ],
       "npm_versions": ["0.12.0"]
+    },
+    {
+      "version": "4.6.0",
+      "files": [
+        {
+          "path": "SKILL.md",
+          "sha256": "df2ebc3f3903cf5abf4eb6612da527cad97a92f29f1a9a475ea6e8b4cf47abfb"
+        },
+        {
+          "path": "references/operations.md",
+          "sha256": "d52f01637e33e65ce523d19a810ce9488ab92228809768ec66a584120c24ad98"
+        }
+      ],
+      "npm_versions": ["0.13.0", "0.13.1"]
+    },
+    {
+      "version": "4.6.0",
+      "files": [
+        {
+          "path": "SKILL.md",
+          "sha256": "33d0c6520c1ed54d42a502251a08baed86153bf9b6c275aed4525b2968f1553b"
+        },
+        {
+          "path": "references/operations.md",
+          "sha256": "d52f01637e33e65ce523d19a810ce9488ab92228809768ec66a584120c24ad98"
+        }
+      ],
+      "npm_versions": ["0.14.0", "0.14.1", "0.14.2", "0.14.3"]
+    },
+    {
+      "version": "4.6.0",
+      "files": [
+        {
+          "path": "SKILL.md",
+          "sha256": "94ff4ce2a97d33cad56b7c1ed8057d0ff7ca22988aebd7923b21319326307c18"
+        },
+        {
+          "path": "references/operations.md",
+          "sha256": "ee5dd8138b4f4570ee256c820c69b94d650a3d454119fff80b1dc08a6297b380"
+        }
+      ],
+      "npm_versions": ["0.15.0"]
+    },
+    {
+      "version": "4.6.0",
+      "files": [
+        {
+          "path": "SKILL.md",
+          "sha256": "afd054a923d9a4f825066e5c3fd2dfa7ae2269a8464819b032a5fbf19a9b14fd"
+        },
+        {
+          "path": "references/operations.md",
+          "sha256": "ee5dd8138b4f4570ee256c820c69b94d650a3d454119fff80b1dc08a6297b380"
+        }
+      ],
+      "npm_versions": ["0.15.1"]
+    },
+    {
+      "version": "4.7.0",
+      "files": [
+        {
+          "path": "SKILL.md",
+          "sha256": "2606e5fc607a3063789c7c02c49aaf8b3129824fa5527b8654e50e95ed2a8556"
+        },
+        {
+          "path": "references/operations.md",
+          "sha256": "c744553832f55d0630d5ff64d3b5f201b8e87c323d6b7bfeb84eb1778e775b7d"
+        }
+      ],
+      "npm_versions": ["0.16.0"]
     }
   ]
 }