@entrorove/skill 0.1.48 → 0.1.50

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 0.1.50 — 2026-10-16
+
+- 修复 tsconfig 的 npm 配置继承，支持包与子路径、exports/typesVersions 及数组继承；按真实 pnpm 来源解析并记录配置哈希。依赖保持只读，越界及无法确定规范来源的引用报告具体路径和原因，保留原任务重试。
+- Fixed tsconfig inheritance from npm packages, including package subpaths, exports/typesVersions and ordered parent arrays. Resolve pnpm configurations from their actual locations and retain metadata hashes. Dependencies remain read-only; escaping or unrepresentable canonical references report their paths and reasons while preserving the original task for retry.
+
+## 0.1.49 — 2026-10-16
+
+- 修复本地签名快照扫描大量源码时的内存耗尽：优先分析当前授权目标，为源码与语法树设置内存边界，并及时释放 Vue 解析缓存。未完整分析的引用明确保持未知，全仓文件哈希与变更核验继续保留；超限目标返回具体路径和限制，原 flow、范围与队列可保留后重试。
+- Fixed memory exhaustion during local signed snapshots of large source repositories: inspect authorized targets first, bound source and syntax-tree retention, and release the Vue parser cache. Unresolved references remain explicitly unknown while whole-repository hashes and change verification are retained. Oversized targets report their exact path and limit so the original flow, scope, and queue can be preserved for retry.
+
 ## 0.1.48 — 2026-10-16
 
 - 新增标准命令 `install --host codex`，仅配置 Codex 并保留 Claude 的配置与技能副本；后续自动更新沿用已配置的宿主范围。安装命令守卫和旧版清理也按目标宿主限界。

package/IDE-EXECUTION.md

@@ -64,7 +64,7 @@ The v2 progress sequence is durable and ordered: the first runtime step reports
 
 When intake returns `workflow-gate`, connect the current repository before invoking that gate: run `npx @entrorove/skill scope-connect <absolute repositoryRoot>` with JSON `{"flowId":"<original flowId>","paths":["<existing source file>"]}` on stdin. Use the concrete existing source files in the task's scope; new files belong in the later plan's declared artifacts. The adapter enrolls an OS-private Ed25519 scope signer for this accepted account and task, answers a server challenge, copies and verifies real source files, and submits the signed facts. It sends hashes and scope metadata rather than source contents or the private key. Enrollment grants scope inspection only; execution evidence and write passes retain their separate authority checks. An operator-configured signer cannot be replaced. After a successful connection, use the returned `nextInput` for `continue`, or explicitly send `payload: {"targetFiles":["<same existing source file>"]}` to the original `workflow-gate`. The connector uses `paths`; the gate uses `targetFiles`. Refresh an expired snapshot by reconnecting the same flow and path set. Show an explicit blocked result; query the original request ID after an unknown transport outcome before considering another attempt.
 
-Scope inspection resolves aliases from actual `tsconfig.json` or `jsconfig.json`, including relative `extends`. For plugin source compiled by a host project whose config is outside the source's ancestors, include `importContexts: [{"sourcePrefix":"<plugin source directory>","configPath":"<actual host tsconfig.json>"}]` in `scope-connect` input. Inspect the real build configuration first; never invent an alias or mark an unresolved import as external. These context paths remain inside the repository, their hashes enter the signed facts, and the local task binding freezes them.
+Scope inspection resolves aliases from actual `tsconfig.json` or `jsconfig.json`, including relative and npm `extends` and ordered inheritance arrays. Npm configuration lookup uses the pinned TypeScript JSON-config resolver over controlled metadata reads, including scoped packages, subpaths, package `tsconfig`, `exports` and `typesVersions`. Configurations and package metadata enter the signed hashes; dependencies are read only, never executed. Repository-local pnpm links use their actual configuration location. Read-only external dependency packages support parents and mappings inside their reference boundary; references requiring an unrepresentable external canonical ancestor fail explicitly rather than selecting a different same-name repository package. For plugin source compiled by a host project whose config is outside the source's ancestors, include `importContexts: [{"sourcePrefix":"<plugin source directory>","configPath":"<actual host tsconfig.json>"}]` in `scope-connect` input. Inspect the real build configuration first; never invent an alias or mark an unresolved import as external. These context paths remain inside the repository, their hashes enter the signed facts, and the local task binding freezes them.
 
 Keep snapshot before-images distinct from a frozen execution plan's expected final file hashes. Controlled writes consume the original approved authority; the runner then verifies the actual planned final bytes. Never edit a signed plan or silently substitute a newer snapshot after an unknown or failed gate. Existing changes outside that authority require explicit revalidation of the same original flow.
 

package/REUSE-DISCIPLINE.md

@@ -2,6 +2,8 @@
 
 Apply these rules when adding to or changing an existing system. Reuse is assessed inside the current accepted repository; external projects, databases, accounts, sessions and keys are outside scope.
 
+Snapshot scans stream whole-repository integrity hashes and bound semantic work to 1 MiB per source, 8 MiB of retained source, 512 files and 200,000 syntax nodes. Original target paths and proposed files receive capacity first. A resource-limited non-target source stays in the integrity comparison and is recorded as unresolved; `scanComplete` is false and absent references cannot prove a symbol unused. A target that exceeds a bound returns `ENTROROVE_DISCIPLINE_ANALYSIS_LIMIT` with its path and the exceeded limit. These are execution memory limits, never size-based review exemptions or approval thresholds. Preserve the original flow, signer, scope and queue during recovery. Upgrade with the standard managed installer, then retry the original `scope-connect` input; do not create a replacement task or bypass the host guard with an arbitrary Node environment wrapper.
+
 - D-1: Before another business mapping or fact definition, search actual definitions and reuse them. Snapshot planning records the whole repository comparison and AST usage review in `discipline-review.json`; its digest is covered by the signed original snapshot. Typed source-entity field mappings use the existing import/alias resolver to identify the same entity, then compare field/value sets. A conflicting second mapping is refused with the existing file and line. An unresolved semantic relation remains unknown. No overlap threshold is invented.
 - D-2: A rewrite must cite a concrete existing defect at file:line. “Clearer”, “more maintainable” and “more general” are not evidence. A necessary sensitive exception is submitted through `continue` → `workflow-discipline-review` on the original planning phase. Display the whole concrete proposal. Approval must be the original account's stored Confirm Protocol answer and audit, never a caller's `accepted:true`.
 - D-3: A parallel path requires frozen `policy.parallelPaths` and actual same-input, fieldwise equivalence evidence. Use the existing GoldenBaseline to pin baseline bytes and source hash. The approved runner reads the baseline and actual process output; the original output cannot be supplied anew by the implementation. Missing evidence yields incomplete, mismatch yields blocked with field names. Baselines come from the existing path's actual independent samples, not the new implementation's self-consistency tests.

package/SKILL.md

@@ -5,7 +5,7 @@ description: Execute an engineering task through Entrorove, preserving its origi
 
 # entrorove · 熵巡
 
-Version: 0.1.48.
+Version: 0.1.50.
 
 Entrorove applies to the whole task once selected. Reading this document or calling an entry once does not execute the task. On every later turn, including after compaction, continue the original task and its required next operation before dependent work. Keep the original goal, scope, account, flow, cloud task and failure records. Never describe planning, a reported step or model output as verified delivery.
 

package/local-discipline-analysis.mjs

@@ -2,6 +2,21 @@ import ts from 'typescript';
 import { archguardScriptSource } from './local-archguard-ast.mjs';
 import { canonical, sha256 } from './local-integrity.mjs';
 
+export const disciplineAnalysisLimits = Object.freeze({ fileBytes: 1_048_576, sourceBytes: 8_388_608, files: 512, nodes: 200_000 });
+function analysisLimit(file, reason, limit, required) {
+  if (required.has(file.path)) throw Object.assign(new Error(`Semantic inspection of "${file.path}" exceeds ${reason} (${limit}); preserve the original flow and split its approved source inspection before retrying`),
+    { code: 'ENTROROVE_DISCIPLINE_ANALYSIS_LIMIT' });
+  return { path: file.path, reason, limit };
+}
+function syntaxNodes(source, limit) {
+  const pending = [source]; let count = 0;
+  while (pending.length) {
+    if (++count > limit) return count;
+    ts.forEachChild(pending.pop(), child => { pending.push(child); });
+  }
+  return count;
+}
+
 const location = (source, node) => ({ path: source.fileName, line: source.getLineAndCharacterOfPosition(node.getStart(source)).line + 1 });
 const unwrap = node => {
   while (node && (ts.isAsExpression(node) || ts.isSatisfiesExpression(node) || ts.isParenthesizedExpression(node))) node = node.expression;
@@ -58,7 +73,7 @@ function definition(source, node) {
   while (ancestor && !ts.isSourceFile(ancestor) && !publicDefinition(ancestor)) ancestor = ancestor.parent;
   const exported = Boolean(ancestor && !ts.isSourceFile(ancestor));
   const contract = exported && (ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node) || ts.isEnumDeclaration(node) || ts.isFunctionDeclaration(node));
-  const signature = ts.isFunctionDeclaration(node) ? canonical({ parameters: node.parameters.map(item => item.getText(source)), type: node.type?.getText(source) ?? null }) : node.getText(source);
+  const signature = !contract ? null : ts.isFunctionDeclaration(node) ? canonical({ parameters: node.parameters.map(item => item.getText(source)), type: node.type?.getText(source) ?? null }) : node.getText(source);
   return { ...location(source, node), symbol, name, exported: Boolean(exported), contract: Boolean(contract),
     signatureDigest: contract ? sha256(signature) : null };
 }
@@ -110,11 +125,24 @@ function programFor(sources, edges) {
   });
   return ts.createProgram([...sources.keys()], { noLib: true, allowJs: true, checkJs: false }, host);
 }
-export function analyzeDisciplineSources(files, { edges = [], unresolved = [] } = {}) {
+export function analyzeDisciplineSources(files, { edges = [], unresolved = [], requiredPaths = [] } = {}) {
   const sources = new Map(), unsupported = [];
+  const required = new Set(requiredPaths); let bytes = 0, nodes = 0;
   for (const file of files) {
+    const size = Buffer.byteLength(file.content);
+    const reason = size > disciplineAnalysisLimits.fileBytes ? 'source-file-byte-limit'
+      : bytes + size > disciplineAnalysisLimits.sourceBytes ? 'source-total-byte-limit'
+        : sources.size >= disciplineAnalysisLimits.files ? 'source-file-count-limit' : null;
+    if (reason) { unsupported.push(analysisLimit(file, reason, reason === 'source-file-byte-limit' ? disciplineAnalysisLimits.fileBytes
+      : reason === 'source-total-byte-limit' ? disciplineAnalysisLimits.sourceBytes : disciplineAnalysisLimits.files, required)); continue; }
+    bytes += size;
     const parsed = archguardScriptSource(file);
     if (!parsed || parsed.parseDiagnostics.length) { unsupported.push({ path: file.path, reason: parsed ? 'syntax-unresolved' : 'language-unresolved' }); continue; }
+    const count = syntaxNodes(parsed, disciplineAnalysisLimits.nodes - nodes);
+    if (nodes + count > disciplineAnalysisLimits.nodes) {
+      unsupported.push(analysisLimit(file, 'syntax-node-limit', disciplineAnalysisLimits.nodes, required)); continue;
+    }
+    nodes += count;
     sources.set(file.path, parsed);
   }
   const program = programFor(sources, edges), checker = program.getTypeChecker(), definitions = [], mappings = [], references = new Map();

package/local-discipline-repository.mjs

@@ -5,7 +5,7 @@ import { canonical, sha256 } from './local-integrity.mjs';
 import { mutationRead14, mutationPath14, mutationTarget14, mutationFail14 } from './local-mutation-files.mjs';
 import { budgetBindingForRead } from './local-budget-reads.mjs';
 import { budgetStatus } from './local-budget.mjs';
-import { analyzeDisciplineSources } from './local-discipline-analysis.mjs';
+import { analyzeDisciplineSources, disciplineAnalysisLimits } from './local-discipline-analysis.mjs';
 import { importGraph, scopeCandidateImports } from './local-scope-repository.mjs';
 import { nativeDisciplineDefinitions } from './local-discipline-native.mjs';
 
@@ -19,6 +19,14 @@ function withinBudgetScope(relative, scope) {
     && !scope.forbiddenPaths?.some(forbidden => within(relative, forbidden));
 }
 const sameFile = (left, right) => ['dev', 'ino', 'size', 'mtimeMs', 'ctimeMs', 'mode'].every(key => left[key] === right[key]);
+function sourceLimit(relative, bytes, sources, used, required) {
+  const reason = bytes > disciplineAnalysisLimits.fileBytes ? 'source-file-byte-limit'
+    : used + bytes > disciplineAnalysisLimits.sourceBytes ? 'source-total-byte-limit'
+      : sources.length >= disciplineAnalysisLimits.files ? 'source-file-count-limit' : null;
+  if (reason && required.has(relative)) mutationFail14('ENTROROVE_DISCIPLINE_ANALYSIS_LIMIT',
+    `Semantic inspection of "${relative}" (${bytes} bytes) exceeds ${reason}; limits are ${disciplineAnalysisLimits.fileBytes} bytes per file, ${disciplineAnalysisLimits.sourceBytes} total bytes and ${disciplineAnalysisLimits.files} files. Preserve the original flow and split its approved inspection before retrying`);
+  return reason;
+}
 async function integrityOnlyFile(root, relative) {
   // This path returns only an integrity digest. It never exposes source bytes or
   // contributes semantic facts outside the signed source-read scope.
@@ -47,12 +55,19 @@ async function inventory(root, prefix = '') {
 }
 export async function disciplineRepositoryObservation(input, root, { analyze = false, overrides = new Map() } = {}) {
   const paths = await inventory(root), files = [], sources = [], unresolved = [];
+  const required = new Set([...(input.paths ?? []), ...(input.targetPath ? [input.targetPath] : []), ...overrides.keys()]);
+  const ordered = [...paths].sort((a, b) => Number(required.has(b)) - Number(required.has(a)) || (a < b ? -1 : a > b ? 1 : 0));
+  let sourceBytes = 0;
   const binding = await budgetBindingForRead(input), budget = binding ? await budgetStatus(binding) : null;
   const restricted = budget?.enforced ? budget.scope : null;
   if (restricted && [...overrides.keys()].some(relative => !withinBudgetScope(relative, restricted))) {
     mutationFail14('ENTROROVE_BUDGET_SCOPE', 'candidate analysis is outside the original cloud task scope');
   }
-  for (const relative of paths) {
+  for (const [relative, content] of overrides) if (analyze && !paths.includes(relative) && semanticSource(relative)) {
+    const bytes = Buffer.byteLength(content); sourceLimit(relative, bytes, sources, sourceBytes, required);
+    sources.push({ path: relative, content }); sourceBytes += bytes;
+  }
+  for (const relative of ordered) {
     const stat = await fs.lstat(path.join(root, relative));
     if (stat.isSymbolicLink()) {
       files.push({ path: relative, sha256: sha256(await fs.readlink(path.join(root, relative))), mode: stat.mode & 0o777, kind: 'symlink' });
@@ -60,24 +75,27 @@ export async function disciplineRepositoryObservation(input, root, { analyze = f
     }
     const semantic = analyze && semanticSource(relative);
     const allowed = !restricted || withinBudgetScope(relative, restricted);
-    const read = semantic && allowed ? await mutationRead14(input, root, relative) : await integrityOnlyFile(root, relative);
+    const bytes = overrides.has(relative) ? Buffer.byteLength(overrides.get(relative)) : stat.size;
+    const limited = semantic && allowed ? sourceLimit(relative, bytes, sources, sourceBytes, required) : null;
+    const read = semantic && allowed && !limited ? await mutationRead14(input, root, relative) : await integrityOnlyFile(root, relative);
     files.push({ path: relative, sha256: read.sha256, mode: read.mode, kind: 'file' });
-    if (semantic && allowed) sources.push({ path: relative, content: overrides.get(relative) ?? read.content.toString('utf8') });
+    if (semantic && allowed && !limited) { sources.push({ path: relative, content: overrides.get(relative) ?? read.content.toString('utf8') }); sourceBytes += bytes; }
+    else if (limited) unresolved.push({ path: relative, reason: limited, bytes });
     else if (semantic && !allowed) unresolved.push({ path: relative, reason: 'outside-signed-source-scope' });
   }
   if (canonical(paths) !== canonical(await inventory(root))) mutationFail14('ENTROROVE_DISCIPLINE_SCAN_CHANGED', 'Repository inventory changed while observing its original baseline');
+  files.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
   const comparison = { schemaVersion: 'entrorove.repository-comparison/1.0', files,
     scope: 'whole-repository-including-ignored-files', excludedDirectoryNames: [...excluded].sort() };
   if (!analyze) return { comparison };
   // The existing resolver supplies actual aliases, package exports and import edges.
   // Unsupported/dynamic references stay unknown; they are never converted to unused.
-  const roots = sources.filter(file => /\.[cm]?[jt]sx?$/i.test(file.path)).map(file => ({ path: file.path, exists: true }));
-  for (const [relative, content] of overrides) if (!paths.includes(relative) && semanticSource(relative)) sources.push({ path: relative, content });
+  const roots = sources.filter(file => paths.includes(file.path) && /\.[cm]?[jt]sx?$/i.test(file.path)).map(file => ({ path: file.path, exists: true }));
   let graph;
-  try { graph = roots.length ? await importGraph(root, roots, input) : { edges: [], dynamicSources: [], complete: true }; }
+  try { graph = roots.length ? await importGraph(root, roots, input, disciplineAnalysisLimits) : { edges: [], dynamicSources: [], complete: true }; }
   catch (error) {
     if (!['ENTROROVE_IMPORT_UNRESOLVED', 'ENTROROVE_IMPORT_INVALID', 'ENTROROVE_IMPORT_UNSUPPORTED', 'ENTROROVE_SCOPE_LIMIT', 'ENTROROVE_BUDGET_SCOPE'].includes(error.code)) throw error;
-    graph = { edges: [], dynamicSources: [], complete: false }; unresolved.push({ reason: error.code });
+    graph = { edges: [], dynamicSources: [], complete: false }; unresolved.push({ reason: error.code, message: error.message });
   }
   for (const [relative, content] of overrides) if (semanticSource(relative) && /\.[cm]?[jt]sx?$/i.test(relative)) {
     try {
@@ -89,7 +107,7 @@ export async function disciplineRepositoryObservation(input, root, { analyze = f
       unresolved.push({ path: relative, reason: error.code });
     }
   }
-  const analysis = analyzeDisciplineSources(sources, { edges: graph.edges,
+  const analysis = analyzeDisciplineSources(sources, { edges: graph.edges, requiredPaths: [...required],
     unresolved: [...unresolved, ...graph.dynamicSources.map(item => ({ path: item.path, reason: 'dynamic-import' }))] });
   analysis.definitions.push(...await nativeDisciplineDefinitions(sources));
   return { comparison, analysis, scanComplete: graph.complete && analysis.unresolved.length === 0 };

package/local-scope-config-extends.mjs

@@ -0,0 +1,71 @@
+import path from 'node:path';
+import ts from 'typescript';
+
+const virtualRoot = '/entrorove-repository/';
+export function assertScopeConfigReference(from, resolved, boundary, field) {
+  if (boundary && resolved !== boundary.path && !resolved.startsWith(`${boundary.path}/`)) {
+    throw new Error(`Scope tsconfig ${field} from "${from}" (canonical "${boundary.resolved}") resolves to "${resolved}" outside read-only dependency reference "${boundary.path}"; its external canonical base cannot be represented inside the authorized repository`);
+  }
+  return resolved;
+}
+function repositoryPath(filename, within) {
+  const normalized = path.posix.normalize(filename);
+  if (!normalized.startsWith(virtualRoot)) return null;
+  return within('', normalized.slice(virtualRoot.length), false, 'extends resolution');
+}
+function validatePackageConfig(relative, source, within, referenceRoot) {
+  if (!relative.endsWith('/package.json')) return;
+  let manifest;
+  try { manifest = JSON.parse(source); }
+  catch { throw new Error(`Scope npm extends package metadata is invalid JSON: ${relative}`); }
+  if (typeof manifest?.tsconfig === 'string') {
+    const resolved = within(path.posix.dirname(relative), manifest.tsconfig, false, `package tsconfig in ${relative}`);
+    assertScopeConfigReference(relative, resolved, referenceRoot(relative), `package tsconfig ${JSON.stringify(manifest.tsconfig)}`);
+  }
+}
+
+/** Replay the pinned TypeScript resolver over asynchronously authorized metadata only. */
+export async function scopeNpmConfig(metadata, fromConfig, specifier, within, canonicalPath, referenceRoot) {
+  if (specifier.split('/').some(part => !part || part === '.' || part === '..')) {
+    throw new Error(`Scope tsconfig extends has an invalid npm specifier: ${JSON.stringify(specifier)} in ${fromConfig}`);
+  }
+  if (referenceRoot(fromConfig)) {
+    const boundary = referenceRoot(fromConfig);
+    throw new Error(`Scope tsconfig npm extends ${JSON.stringify(specifier)} from "${fromConfig}" resolves through external canonical configuration "${boundary.resolved}"; ancestor package lookup outside dependency reference "${boundary.path}" cannot be represented inside the authorized repository`);
+  }
+  const sources = new Map(), pending = Symbol('authorized-config-read');
+  const lookup = filename => {
+    const relative = repositoryPath(filename, within);
+    if (relative === null) return null;
+    if (!sources.has(relative)) throw { pending, relative };
+    return sources.get(relative);
+  };
+  const host = {
+    fileExists: filename => lookup(filename) !== null,
+    readFile: filename => lookup(filename) ?? undefined,
+    getCurrentDirectory: () => virtualRoot.slice(0, -1),
+    getGlobalTypingsCacheLocation: () => virtualRoot.slice(0, -1),
+    useCaseSensitiveFileNames: true,
+    realpath: filename => {
+      const relative = repositoryPath(filename, within);
+      return relative === null ? filename : virtualRoot + within('', canonicalPath(relative), false, 'dependency realpath');
+    },
+  };
+  for (let probes = 0; probes < 1024; probes++) {
+    try {
+      const result = ts.nodeNextJsonConfigResolver(specifier, virtualRoot + fromConfig, host);
+      if (!result.resolvedModule) {
+        throw new Error(`Scope tsconfig npm extends ${JSON.stringify(specifier)} in ${fromConfig} references a missing or unexported actual configuration within the authorized repository`);
+      }
+      const relative = repositoryPath(result.resolvedModule.resolvedFileName, within);
+      if (relative === null) throw new Error(`Scope tsconfig npm extends ${JSON.stringify(specifier)} resolved outside the authorized repository`);
+      return relative;
+    } catch (error) {
+      if (error?.pending !== pending) throw error;
+      const source = await metadata(error.relative);
+      if (source !== null) validatePackageConfig(error.relative, source, within, referenceRoot);
+      sources.set(error.relative, source);
+    }
+  }
+  throw new Error(`Scope tsconfig npm extends ${JSON.stringify(specifier)} in ${fromConfig} exceeds the 1024-metadata-probe bound`);
+}

package/local-scope-config-imports.mjs

@@ -1,6 +1,7 @@
 import { createHash } from 'node:crypto';
 import path from 'node:path';
 import ts from 'typescript';
+import { scopeNpmConfig, assertScopeConfigReference } from './local-scope-config-extends.mjs';
 const missing = (error) => ['ENOENT', 'ENOTDIR'].includes(error?.code ?? '');
 function literal(value, field) {
     if (typeof value !== 'string' || !value || value !== value.trim() || value !== value.normalize('NFC')
@@ -81,6 +82,11 @@ function pathMatch(paths, specifier) {
     }
     return selected;
 }
+function configCandidate(resolution, target) {
+    const base = resolution.baseUrl ?? resolution.pathsOrigin;
+    const boundary = resolution.baseUrl === undefined ? resolution.pathsReferenceRoot : resolution.baseUrlReferenceRoot;
+    return assertScopeConfigReference(base || '.', within(base, target), boundary, `mapping ${JSON.stringify(target)}`);
+}
 function importCandidates(resolution, specifier) {
     if (typeof specifier !== 'string' || !specifier)
         throw new Error('Scope tsconfig import specifier must be nonempty');
@@ -92,18 +98,14 @@ function importCandidates(resolution, specifier) {
     }
     const match = pathMatch(resolution?.paths, specifier);
     if (match) {
-        const base = resolution.baseUrl ?? resolution.pathsOrigin;
-        return [...new Set(match.targets.map(target => within(base, target.replace('*', match.wildcard))))];
+        return [...new Set(match.targets.map(target => configCandidate(resolution, target.replace('*', match.wildcard))))];
     }
     if (specifier.startsWith('@/') || specifier.startsWith('#') || specifier.startsWith('~/')) {
         throw new Error('Scope local import alias requires an actual tsconfig or package-import mapping');
     }
-    return resolution?.baseUrl !== undefined ? [within(resolution.baseUrl, specifier)] : [];
+    return resolution?.baseUrl !== undefined ? [configCandidate(resolution, specifier)] : [];
 }
-export async function scopeTsconfigImports(read, fromFile, configPath) {
-    const canonical = within('', fromFile);
-    if (canonical !== fromFile)
-        throw new Error('Scope tsconfig source path must be canonical within the repository');
+function configObservations(read) {
     const observed = new Map();
     const absent = new Set();
     let bytes = 0;
@@ -135,34 +137,50 @@ export async function scopeTsconfigImports(read, fromFile, configPath) {
         observed.set(relative, item);
         return data.toString('utf8');
     };
+    return { metadata, canonicalPath: relative => observed.get(relative)?.realPath ?? relative,
+        referenceRoot: relative => observed.get(relative)?.referenceRoot,
+        observations: () => [...observed.keys()].sort().map(relative => ({ path: relative, sha256: observed.get(relative).sha256 })) };
+}
+export async function scopeTsconfigImports(read, fromFile, configPath) {
+    const canonical = within('', fromFile);
+    if (canonical !== fromFile)
+        throw new Error('Scope tsconfig source path must be canonical within the repository');
+    const { metadata, canonicalPath, referenceRoot, observations } = configObservations(read);
+    let configurations = 0;
     const load = async (relative, ancestors, depth = 0) => {
-        if (depth >= 10)
-            throw new Error('Scope tsconfig extends exceeds the 10-configuration depth bound');
+        if (depth >= 10 || ++configurations > 512)
+            throw new Error('Scope tsconfig extends exceeds its 10-configuration depth or 512-configuration inspection bound');
         let source = await metadata(relative);
         if (source === null && !relative.endsWith('.json')) {
             relative += '.json';
             source = await metadata(relative);
         }
         if (source === null)
-            throw new Error('Scope tsconfig extends references a missing actual configuration');
+            throw new Error(`Scope tsconfig extends references a missing actual configuration: ${relative}`);
         if (ancestors.has(relative))
             throw new Error('Scope tsconfig extends contains a configuration cycle');
         const config = parsedConfig(relative, source);
         const directory = path.posix.dirname(relative) === '.' ? '' : path.posix.dirname(relative);
-        let inherited = { pathsOrigin: directory };
+        let inherited = {};
         if (config.extends !== undefined) {
-            const extended = literal(config.extends, 'extends');
-            if (!extended.startsWith('./') && !extended.startsWith('../'))
-                throw new Error('Scope tsconfig npm extends is unsupported; use an actual repository-relative extends');
-            inherited = await load(within(directory, extended, false, 'extends'), new Set([...ancestors, relative]), depth + 1);
+            const parents = Array.isArray(config.extends) ? config.extends : [config.extends];
+            if (parents.length > 128) throw new Error(`Scope tsconfig extends in ${relative} exceeds the 128-parent bound`);
+            for (const parent of parents) {
+                const extended = literal(parent, 'extends');
+                const target = extended.startsWith('./') || extended.startsWith('../')
+                    ? assertScopeConfigReference(relative, within(directory, extended, false, 'extends'), referenceRoot(relative), `extends ${JSON.stringify(extended)}`)
+                    : await scopeNpmConfig(metadata, relative, extended, within, canonicalPath, referenceRoot);
+                inherited = { ...inherited, ...await load(target, new Set([...ancestors, relative]), depth + 1) };
+            }
         }
         const options = config.compilerOptions === undefined ? {} : config.compilerOptions;
         if (!options || typeof options !== 'object' || Array.isArray(options))
             throw new Error('Scope tsconfig compilerOptions must be an object');
         const own = options;
         return { ...inherited,
-            ...(own.baseUrl === undefined ? {} : { baseUrl: within(directory, own.baseUrl, true, 'baseUrl') }),
-            ...(own.paths === undefined ? {} : { paths: pathsOption(own.paths), pathsOrigin: directory }) };
+            ...(own.baseUrl === undefined ? {} : { baseUrl: assertScopeConfigReference(relative, within(directory, own.baseUrl, true, 'baseUrl'), referenceRoot(relative), `baseUrl ${JSON.stringify(own.baseUrl)}`),
+                baseUrlReferenceRoot: referenceRoot(relative) }),
+            ...(own.paths === undefined ? {} : { paths: pathsOption(own.paths), pathsOrigin: directory, pathsReferenceRoot: referenceRoot(relative) }) };
     };
     let directory = path.posix.dirname(canonical);
     let resolution = null;
@@ -186,12 +204,11 @@ export async function scopeTsconfigImports(read, fromFile, configPath) {
     if (resolution?.paths)
         for (const targets of Object.values(resolution.paths))
             for (const target of targets) {
-                within(resolution.baseUrl ?? resolution.pathsOrigin, target.replace('*', '__scope_wildcard__'), false, 'mapping');
+                configCandidate(resolution, target.replace('*', '__scope_wildcard__'));
             }
     return { candidates: specifier => importCandidates(resolution, specifier), mapped: specifier => {
             if (typeof specifier !== 'string' || !specifier)
                 throw new Error('Scope tsconfig mapping lookup requires a nonempty specifier');
             return pathMatch(resolution?.paths, specifier) !== null;
-        }, observations: [...observed.keys()].sort()
-            .map(relative => ({ path: relative, sha256: observed.get(relative).sha256 })) };
+        }, observations: observations() };
 }

package/local-scope-repository.mjs

@@ -4,7 +4,7 @@ import path from 'node:path';
 import { promisify } from 'node:util';
 import { builtinModules } from 'node:module';
 import ts from 'typescript';
-import { parse as parseVue } from '@vue/compiler-sfc';
+import { parse as parseVue, parseCache as vueParseCache } from '@vue/compiler-sfc';
 import { lineCount, observedScopeRisk, packageBoundary, scopeFail, scopeFiles, scopeRead, scopeTarget, stableScope } from './local-scope-files.mjs';
 import { sha256 } from './local-integrity.mjs';
 import { workspaceImport, workspaceIndex } from './local-scope-workspaces.mjs';
@@ -142,6 +142,7 @@ function scriptImports(source, filename) {
 function vueScripts(source, filename) {
   const { descriptor, errors } = parseVue(source, { filename, sourceMap: false,
     templateParseOptions: { expressionPlugins: ['typescript'] } });
+  vueParseCache.clear();
   if (errors.length) scopeFail('ENTROROVE_IMPORT_INVALID', 'component has invalid or unterminated syntax');
   if (descriptor.customBlocks.length || descriptor.template?.lang || descriptor.template?.src) {
     scopeFail('ENTROROVE_IMPORT_UNSUPPORTED', 'component dependency inspection requires supported inline template syntax');
@@ -215,6 +216,27 @@ async function resolveImport(root, from, specifier, workspace, input, aliases, c
   return resolveLocalImport(root, relative);
 }
 const dependencyReference = relative => relative.split('/').includes('node_modules');
+async function externalConfigReference(root, relative, resolved) {
+  const parts = relative.split('/'); let previous = root, boundary;
+  for (let index = 1; index <= parts.length; index++) {
+    const prefix = parts.slice(0, index).join('/'), current = await fs.realpath(path.join(root, prefix));
+    if (current !== root && !current.startsWith(`${root}${path.sep}`) && current !== path.join(previous, parts[index - 1])) {
+      boundary = { path: prefix, resolved };
+    }
+    previous = current;
+  }
+  return boundary;
+}
+async function configMetadata(root, relative, input) {
+  const target = await scopeTarget(root, relative, true, dependencyReference(relative));
+  if (!target.exists || !target.stat.isFile()) throw Object.assign(new Error(`Missing configuration file: ${relative}`), { code: 'ENOENT' });
+  const read = await scopeRead(root, relative, input), resolved = await fs.realpath(target.target);
+  const physical = path.relative(root, resolved).split(path.sep).join('/');
+  const outside = physical === '..' || physical.startsWith('../') || path.isAbsolute(physical);
+  const realPath = outside ? relative : physical;
+  const referenceRoot = outside ? await externalConfigReference(root, relative, resolved) : undefined;
+  return { path: relative, sha256: read.sha256, contentBase64: read.content.toString('base64'), realPath, referenceRoot };
+}
 async function resolveLocalImport(root, relative, required = true) {
   if (relative.startsWith('../') || relative === '..') scopeFail('ENTROROVE_PATH_UNSAFE', 'local import escapes the repository');
   const replacements = /\.js$/.test(relative) ? [relative.replace(/\.js$/, '.ts'), relative.replace(/\.js$/, '.tsx')] : [];
@@ -225,24 +247,29 @@ async function resolveLocalImport(root, relative, required = true) {
   if (required) scopeFail('ENTROROVE_IMPORT_UNRESOLVED', 'a local import has no resolvable source file');
   return null;
 }
-export async function importGraph(root, originals, input = { repositoryRoot: root }) {
+export async function importGraph(root, originals, input = { repositoryRoot: root }, limits = {}) {
   const pending = originals.filter(file => file.exists !== false).map(file => file.path); const visited = new Map(); const edges = []; let dynamic = false;
+  let sourceBytes = 0;
   const dynamicSources = [];
   const workspace = await workspaceIndex(root, input);
   const metadata = new Map(workspace.metadata.map(item => [item.path, item]));
   while (pending.length) {
     const relative = pending.shift(); if (visited.has(relative)) continue;
     if (visited.size >= 1000) scopeFail('ENTROROVE_SCOPE_LIMIT', 'import graph exceeds the 1000-file inspection bound');
+    if (limits.fileBytes || limits.sourceBytes) {
+      const target = await scopeTarget(root, relative, false, dependencyReference(relative));
+      if (target.stat.size > (limits.fileBytes ?? Infinity) || sourceBytes + target.stat.size > (limits.sourceBytes ?? Infinity)) {
+        scopeFail('ENTROROVE_SCOPE_LIMIT', `Import inspection of "${relative}" (${target.stat.size} bytes) exceeds its bounded semantic scan (${limits.fileBytes} bytes per file, ${limits.sourceBytes} total bytes)`);
+      }
+      sourceBytes += target.stat.size;
+    }
     const read = await scopeRead(root, relative, input); const boundary = await packageBoundary(root, relative, input);
     visited.set(relative, { path: relative, sha256: read.sha256, module: boundary.path, boundary });
     if (!sourceExtension.test(relative)) continue;
     const contexts = (input.importContexts ?? []).filter(context => relative === context.sourcePrefix || relative.startsWith(`${context.sourcePrefix}/`))
       .sort((a, b) => b.sourcePrefix.length - a.sourcePrefix.length);
     const configPath = contexts[0]?.configPath;
-    const aliases = await scopeTsconfigImports(async target => {
-      const item = await scopeRead(root, target, input);
-      return { path: target, sha256: item.sha256, contentBase64: item.content.toString('base64') };
-    }, relative, configPath);
+    const aliases = await scopeTsconfigImports(target => configMetadata(root, target, input), relative, configPath);
     for (const observed of aliases.observations) metadata.set(observed.path, observed);
     const declarations = declarationModules(read.content, relative);
     const imports = importSpecifiers(read.content, relative); dynamic ||= imports.dynamic;
@@ -266,10 +293,7 @@ export async function scopeCandidateImports(root, file, input = { repositoryRoot
   const workspace = await workspaceIndex(root, input);
   const context = (input.importContexts ?? []).filter(item => file.path === item.sourcePrefix || file.path.startsWith(`${item.sourcePrefix}/`))
     .sort((a, b) => b.sourcePrefix.length - a.sourcePrefix.length)[0];
-  const aliases = await scopeTsconfigImports(async relative => {
-    const read = await scopeRead(root, relative, input);
-    return { path: relative, sha256: read.sha256, contentBase64: read.content.toString('base64') };
-  }, file.path, context?.configPath);
+  const aliases = await scopeTsconfigImports(relative => configMetadata(root, relative, input), file.path, context?.configPath);
   const declarations = declarationModules(Buffer.from(file.content), file.path), edges = [];
   for (const specifier of parsed.specifiers) {
     const target = await resolveImport(root, file.path, specifier, workspace, input, aliases, context?.configPath, declarations);

package/manifest.json

@@ -1,7 +1,7 @@
 {
   "schemaVersion": "entrorove.skill-manifest/1.0",
   "name": "entrorove",
-  "version": "0.1.48",
+  "version": "0.1.50",
   "endpoint": "https://entrorove.com",
   "requestSchemaVersion": "entrorove.skill.request/2.0",
   "supportedRequestSchemaVersions": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@entrorove/skill",
-  "version": "0.1.48",
+  "version": "0.1.50",
   "type": "module",
   "bin": {
     "entrorove": "cli.mjs"
@@ -135,6 +135,7 @@
     "local-scope-repository.mjs",
     "local-scope-signature.mjs",
     "local-scope-config-imports.mjs",
+    "local-scope-config-extends.mjs",
     "local-scope-snapshot.mjs",
     "local-scope-state.mjs",
     "local-scope-workspaces.mjs",

package/release-state.json

@@ -1,7 +1,7 @@
 {
   "schemaVersion": "entrorove.release-state/1.0",
-  "version": "0.1.48",
-  "digest": "6f79c0e2c12d4e8766801bf117bcf73070156ba89fb87e4b1137c9706b8f7df3",
+  "version": "0.1.50",
+  "digest": "c749866399a99cf122f71c00dca31cf49706a76f0998b7f3197d0763968468b5",
   "files": {
     "ide-code-mode.mjs": "f3f53357ba09727b3b597851976a24de93287c0faca5052448277d0904bb61f7",
     "ide-command.mjs": "dcd4b48305cc4f106e5e4509e794e4b46ef02de29afa9cccbbc2774308c81ff3",
@@ -12,14 +12,14 @@
     "ide-results.mjs": "dfe0d3f773c65a9fc21056538d7005012c982ed4509bc0410d7f62813d0863fd",
     "ide-queue.mjs": "806e716c775fd0079417027b135977c8516f47dddb0bc5ca19e32a355dab0e9e",
     "local-discipline-actions.mjs": "2379c08d0f49c44068f8239db7e514d75885f4606b1b88a7a36e4ff19167caca",
-    "local-discipline-analysis.mjs": "ebea932438a53a157d5d07a5d68366496eee121a2c67cecfb4fdb2d5aa9763eb",
+    "local-discipline-analysis.mjs": "f49e67a2eb2f19f8eb7c4226d481842b38c0f19b495ad0149cbf649baae16bb9",
     "local-discipline-batch.mjs": "2cc90dbae55efdee0c445da399c0a9acafa92e915344c25208ebca554fc4c9e9",
     "local-discipline-contracts.mjs": "6cf8a3d132fdb9074eb1441600afe7aa199df33e88a71a660d9db534c14f19e4",
     "local-discipline-contracts.d.mts": "defc684c78dc88afa1c54340ab4a01ae36db7aa11257cbe1f5cd323f608c78c4",
     "local-discipline-gate.mjs": "04b1ba092d7f4342a0e77cfbeb44d9634dbce9fec0c79e6a1e4b11a662d904ac",
     "local-discipline-native.mjs": "8b99b5ce951cab3c1426428ad807650c61c0ffb2c346d747b73b99057b382049",
     "local-discipline-operations.mjs": "9fcb7b8889b7718d42e1d37936485d8198d5017d405e0cdbbabdbbd12fcc9d48",
-    "local-discipline-repository.mjs": "d818aa6137459ef200892479cc8c47fe82c884dc0e76dc7e6d45a6b41a13c6ec",
+    "local-discipline-repository.mjs": "ffd31e9b2946a9784d4ab59cee5345318d2152816ce995ed5dac11efa4096bc4",
     "local-discipline-snapshot.mjs": "8fd35b2cfbece8f64579f144f589a66dec9b6022d50fe931c4c1f886cb83134d",
     "local-runner-discipline.mjs": "86f451de2f1e12a24f5596a29828891c1eba13cd4714ed0c18a77d66cecef934",
     "local-integrity.d.mts": "21357f306234bd841c0d3d90bf2d09f7663f63746f897b9f38190428ae8198b3",
@@ -29,8 +29,8 @@
     "runtime/validator-runtime-v7.0.44.d.mts": "7797edbfe2f7de24da370204dce4dfd22822a1bd80df93514fff900b98afe36f",
     "snapshot-retention.mjs": "4f8919fe8ec49fb4c23e080a8ad2fa3a9282bca3fffe7cf55c64e89ef316697e",
     "snapshot-cleanup-journal.mjs": "76a9684cc95b4eb076e1298d78a9dff37948b00d9607b8f546c599072d3ed331",
-    "IDE-EXECUTION.md": "6c8b9abe17cc8f01aa3da2ab19ed34b2b9be3e3b38c1739fa6a7d763622c4864",
-    "REUSE-DISCIPLINE.md": "295ecd41c931b00c21d009ab65ac160f0e2ab81b4000ed498d2e8e97c2dc6c63",
+    "IDE-EXECUTION.md": "4e76abb3b2e357de07665d7422204ce710af3cafc0ef946816de73bf1a8998e6",
+    "REUSE-DISCIPLINE.md": "5b214cf313e7f715f52d54e28093a2d038f0f196ca64b15d1c49587b9d8eecf8",
     "reuse-discipline-release.mjs": "20ded9c21bd71b8779c454f5eba4c7c0a943ef99d94117b9bbef891d2ab6e3de",
     "local-final-gate16.mjs": "083aec470670e6cdb7ad2ab27b7a51b53a9ec3a8b4121cb9cbfa17d9940892c2",
     "local-final-gate16-checks.mjs": "1dd30e9666d458d8b12ca6e4975f6f0ac8450c3ea9cbecc7401ae037f66b589a",
@@ -81,9 +81,9 @@
     "CAPABILITY-MAP.md": "a0f0468a098725ced52a96dd8e22bfc7d1ce7681a8446ebf7dae3696c76c3385",
     "AGREEMENT.md": "f93a68e92c457200dd024610e65f74e478b8f60860f951da818b70561f1b9bf8",
     "DELIVERY-BOUNDARIES.md": "d1bb2895e23fc14bf1c76707bd1f6f03b39695501a78a0b7289dc37b099889dc",
-    "package.json": "8be823b5756da9b393af966a4152bee301cb49f988823aaf757e8c51bf867085",
+    "package.json": "cdb1f686304d5d29d1feff1b1ec5b75e4e3dcff1f1da841dfb59d0502ab261e8",
     "manifest.json": "ab06e307795bc9da5add926752b6c4dbdaf18625090261a035aa356a679c504f",
-    "release.mjs": "34a3da868e8b5b586b318f2e8275f2f238d48a20afceb7d51c0f783a120f6973",
+    "release.mjs": "e206cb6cabbb02542317bce283f7ba674621e67765a3eacef5741f2d6b1c58b2",
     "local-cli.mjs": "11461e4cf4f6a8612ff275bf8296ec57ff22281156cb2c72834d3c764ba422a1",
     "local-state-lock.mjs": "1dbf64264642a0851faf043e07ee9f66d2ad0508e9f799b0626246e42fae893e",
     "local-execution.mjs": "46fddd78cd954fb080c660affe90cdaa716695580427336acb820089441a8025",
@@ -122,7 +122,7 @@
     "local-scope-candidate.mjs": "8f0bd9606e70d4a0ebacdd3cd600ec3afed85e2bb3e1760aa1144cf55d4e028a",
     "local-scope-context.mjs": "79753abfc6c76089d17f003a1be537dfaea10d6731c542f7fc53f2a9996ed164",
     "local-scope-files.mjs": "96c301f2a45e5fa22f0b11fb15e5e564f118e53187fc7749263c78d5ed87b056",
-    "local-scope-repository.mjs": "0c955612d2f737e8661af84c1efb6e9e7fe6bb9ec1dfadd7776c61be177261f2",
+    "local-scope-repository.mjs": "56d7874326de2f90e47cf13d6b9839372044ea70ab15fbb7f7125bd13a87a087",
     "local-scope-git.mjs": "53bbbb6c4795db711b5bc164591a6ad79a561427da046d6bbe997dae6eb82829",
     "local-scope-git-reads.mjs": "5d8a2636bab955cb325cb693db7423e69512355887ae5b5af3b8cb615f5ddad0",
     "local-git-executable.mjs": "9391d716529025b1de3ee006df658a9d765b6ef29ad24ef9b7436829318e651e",
@@ -147,7 +147,8 @@
     "runtime/git-native-linux-v1.mjs": "cf5cb91426a105e62c0f07a8a230dec592dba46f85a3f708b4c4e8cfcd1126c6",
     "runtime/git-native-darwin-v1.mjs": "f88aab72dc86f94eb1115784872957cb8ed0f74205ae70e1ecd1939e7790e310",
     "local-scope-signature.mjs": "bd05e8cf9e23f9511a16844974362297b9e9d11930ff7b8ad2a490e8d7660fe9",
-    "local-scope-config-imports.mjs": "53e510609066355318d886cd96f73a0fc8005a28857f6ab4eb6cb81c4857945b",
+    "local-scope-config-imports.mjs": "a399407227bbdd14468633bb6d25586df7c6a30a1ef0d1a80ab7c7b499d3fadf",
+    "local-scope-config-extends.mjs": "3ab4150b846b247e9e0851221123f220c5574699af651830e751f026ab33659e",
     "local-scope-snapshot.mjs": "c0f851470b98863a1d187825ed61ee6072d1c057b178fdc85ae29af02a3b250f",
     "local-scope-state.mjs": "8b600a91fc0068d7a8c0bb752ddba7ed30ada93daafb118d6cba2368fd94cb27",
     "local-scope-workspaces.mjs": "a44c34537e5ed2dcaf193a985e5bc05957989fbb160a650f9e37ba7d66eb2de8",

package/release.mjs

@@ -90,6 +90,7 @@ const sourceFiles = [
   'runtime/git-native-darwin-v1.mjs',
   'local-scope-signature.mjs',
   'local-scope-config-imports.mjs',
+  'local-scope-config-extends.mjs',
   'local-scope-snapshot.mjs',
   'local-scope-state.mjs',
   'local-scope-workspaces.mjs',
@@ -340,6 +341,7 @@ function releaseLabels() {
     'local-scope-files.mjs': { zh: '范围文件与安全读取', en: 'scope files and guarded reads' },
     'local-scope-repository.mjs': { zh: '真实仓库范围事实', en: 'actual repository scope facts' },
     'local-scope-config-imports.mjs': { zh: 'tsconfig 范围路径与依赖只读引用', en: 'tsconfig scope paths and read-only dependency references' },
+    'local-scope-config-extends.mjs': { zh: 'tsconfig npm 配置继承解析', en: 'tsconfig npm configuration inheritance resolution' },
     'local-scope-git.mjs': { zh: '实际Git范围与变更事实', en: 'actual Git scope and change facts' },
     'local-scope-git-reads.mjs': { zh: '固定Git元数据与源码读取', en: 'fixed Git metadata and source reads' },
     'local-scope-git-comparison.mjs': { zh: 'Git范围比较接线', en: 'Git scope comparison wiring' },

package/releases.json

@@ -1,4 +1,16 @@
 [
+  {
+    "version": "0.1.50",
+    "date": "2026-10-16",
+    "zh": "修复 tsconfig 的 npm 配置继承，支持包与子路径、exports/typesVersions 及数组继承；按真实 pnpm 来源解析并记录配置哈希。依赖保持只读，越界及无法确定规范来源的引用报告具体路径和原因，保留原任务重试。",
+    "en": "Fixed tsconfig inheritance from npm packages, including package subpaths, exports/typesVersions and ordered parent arrays. Resolve pnpm configurations from their actual locations and retain metadata hashes. Dependencies remain read-only; escaping or unrepresentable canonical references report their paths and reasons while preserving the original task for retry."
+  },
+  {
+    "version": "0.1.49",
+    "date": "2026-10-16",
+    "zh": "修复本地签名快照扫描大量源码时的内存耗尽：优先分析当前授权目标，为源码与语法树设置内存边界，并及时释放 Vue 解析缓存。未完整分析的引用明确保持未知，全仓文件哈希与变更核验继续保留；超限目标返回具体路径和限制，原 flow、范围与队列可保留后重试。",
+    "en": "Fixed memory exhaustion during local signed snapshots of large source repositories: inspect authorized targets first, bound source and syntax-tree retention, and release the Vue parser cache. Unresolved references remain explicitly unknown while whole-repository hashes and change verification are retained. Oversized targets report their exact path and limit so the original flow, scope, and queue can be preserved for retry."
+  },
   {
     "version": "0.1.48",
     "date": "2026-10-16",