agentsmesh 0.31.0 → 0.32.0

package/dist/engine.d.ts

@@ -132,10 +132,14 @@ declare function formatDiffSummary(summary: DiffSummary): string;
  */
 
 interface LockSyncReport {
-    /** True when the canonical state matches the lock file and no extend drifted. */
+    /** True when canonical state and checked generated outputs are all in sync. */
     readonly inSync: boolean;
     /** True when a `.lock` file was found at the canonical directory. */
     readonly hasLock: boolean;
+    /** True when canonical files or extends differ from the lock. */
+    readonly canonicalDrift: boolean;
+    /** True when a generated output is modified, removed, or stale. */
+    readonly outputDrift: boolean;
     /** Canonical files whose checksum differs from the lock. */
     readonly modified: readonly string[];
     /** Canonical files present now but not in the lock. */
@@ -153,6 +157,8 @@ interface LockSyncReport {
     readonly outputsModified: readonly string[];
     /** Generated outputs recorded in the lock but missing from disk. */
     readonly outputsRemoved: readonly string[];
+    /** Managed generated outputs present on disk but absent from the lock. */
+    readonly outputsStale: readonly string[];
     /**
      * True when output drift was actually verified — requires `rootBase` and a
      * lock with an `outputs` map. False for old-format locks or when no
@@ -171,6 +177,8 @@ interface CheckLockSyncOptions {
      * verification is skipped (keeps the programmatic API backward compatible).
      */
     readonly rootBase?: string;
+    /** Output-layout scope used when scanning managed locations for stale files. */
+    readonly scope?: TargetLayoutScope;
 }
 
 declare function importFrom(target: string, opts: {

package/dist/engine.js

@@ -27259,14 +27259,56 @@ async function diffOutputChecksums(rootBase, lockOutputs) {
   return { outputsModified, outputsRemoved };
 }
 
+// src/core/generate/stale-cleanup.ts
+init_fs();
+init_builtin_targets();
+async function listFiles2(root, base = root) {
+  const entries = await readdir(root, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    const abs = join(root, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await listFiles2(abs, base));
+      continue;
+    }
+    files.push(relative(base, abs).replace(/\\/g, "/"));
+  }
+  return files;
+}
+async function findStaleGeneratedOutputs(args) {
+  const expected = new Set(args.expectedPaths);
+  const stale = /* @__PURE__ */ new Set();
+  const scope = args.scope ?? "project";
+  for (const target31 of args.targets) {
+    const managed = getTargetManagedOutputs(target31, scope);
+    if (!managed) continue;
+    for (const file of managed.files) stale.add(file);
+    for (const dir of managed.dirs) {
+      const absDir = join(args.projectRoot, dir);
+      if (!await exists(absDir)) continue;
+      for (const file of await listFiles2(absDir)) {
+        stale.add(`${dir}/${file}`.replace(/\/+/g, "/"));
+      }
+    }
+  }
+  const found = [];
+  for (const relPath of stale) {
+    if (expected.has(relPath)) continue;
+    if (await exists(join(args.projectRoot, relPath))) found.push(relPath);
+  }
+  return found.sort();
+}
+
 // src/core/check/lock-sync.ts
 async function checkLockSync(opts) {
-  const { config, configDir, canonicalDir, rootBase } = opts;
+  const { config, configDir, canonicalDir, rootBase, scope = "project" } = opts;
   const lock = await readLock(canonicalDir);
   if (lock === null) {
     return {
       inSync: false,
       hasLock: false,
+      canonicalDrift: false,
+      outputDrift: false,
       modified: [],
       added: [],
       removed: [],
@@ -27274,6 +27316,7 @@ async function checkLockSync(opts) {
       lockedViolations: [],
       outputsModified: [],
       outputsRemoved: [],
+      outputsStale: [],
       outputsChecked: false
     };
   }
@@ -27312,10 +27355,20 @@ async function checkLockSync(opts) {
   );
   const outputsChecked = rootBase !== void 0 && lock.outputs !== void 0;
   const { outputsModified, outputsRemoved } = outputsChecked ? await diffOutputChecksums(rootBase, lock.outputs ?? {}) : { outputsModified: [], outputsRemoved: [] };
-  const inSync = modified.length === 0 && added.length === 0 && removed.length === 0 && extendsModified.length === 0 && outputsModified.length === 0 && outputsRemoved.length === 0;
+  const outputsStale = rootBase !== void 0 && lock.outputs !== void 0 ? await findStaleGeneratedOutputs({
+    projectRoot: rootBase,
+    targets: [...config.targets, ...config.pluginTargets ?? []],
+    expectedPaths: Object.keys(lock.outputs),
+    scope
+  }) : [];
+  const canonicalDrift = modified.length > 0 || added.length > 0 || removed.length > 0 || extendsModified.length > 0;
+  const outputDrift = outputsModified.length > 0 || outputsRemoved.length > 0 || outputsStale.length > 0;
+  const inSync = !canonicalDrift && !outputDrift;
   return {
     inSync,
     hasLock: true,
+    canonicalDrift,
+    outputDrift,
     modified,
     added,
     removed,
@@ -27323,6 +27376,7 @@ async function checkLockSync(opts) {
     lockedViolations,
     outputsModified,
     outputsRemoved,
+    outputsStale,
     outputsChecked
   };
 }