@skaile/workspaces 6.2.0 → 6.4.0

package/dist/{chunk-PKBLJI23.js → chunk-TGB4E5Z6.js}

@@ -1,19 +1,19 @@
-import { unregisteredLibraryNames, renamedLibraryName, resolveConfig, RemoteCatalogSource, OfflineError, describeCatalogError, CatalogHttpError, scanUnlistedAssets, missingRootAssets, storeManifestFile, missingLibraryDirMessage, lastLibraryName, filesEntryPaths } from './chunk-6CYKTHNT.js';
-import { SEMVER_RE, invalidSemverMessage, flowFileNameError, computeDeterministicHash, readManifestSourceConfig, discoverAssetsInTree, isManifestMode } from './chunk-MAZ3UXJK.js';
+import { unregisteredLibraryNames, renamedLibraryName, resolveConfig, RemoteCatalogSource, OfflineError, describeCatalogError, CatalogHttpError, scanUnlistedAssets, missingRootAssets, storeManifestFile, missingLibraryDirMessage, lastLibraryName, filesEntryPaths } from './chunk-GBXQFJ4G.js';
+import { SEMVER_RE, invalidSemverMessage, flowFileNameError, computeDeterministicHash, readManifestSourceConfig, discoverAssetsInTree, isManifestMode } from './chunk-WENTJ5KP.js';
 import { parseFlowDefinition } from './chunk-JRN5QF4C.js';
-import { installTargetOf, readKeptLegacyCopies, writeKeptLegacyCopies, canonicalEntryRef, diffDeployedAgent, deployedAssetDrift, assertNoLibrarySymlinks, deployAll, removeAsset, composedDriftRefs, sourceComposedFiles, cachedComposedFiles, createScaffold, installAgent } from './chunk-S2H3RBK7.js';
+import { installTargetOf, readKeptLegacyCopies, writeKeptLegacyCopies, canonicalEntryRef, diffDeployedAgent, deployedAssetDrift, assertNoLibrarySymlinks, deployAll, removeAsset, composedDriftRefs, sourceComposedFiles, cachedComposedFiles, createScaffold, installAgent } from './chunk-YJNE4V2M.js';
 import { appendHistory, getRecentHistory, clearHistory } from './chunk-KTBKW2FI.js';
 import { commitChanges } from './chunk-UQ6LFBPZ.js';
-import { harnessTargetSupportsAgents, CODEX_IDENTITY_DIR, agentRenderFiles } from './chunk-COAFAYBS.js';
+import { harnessTargetSupportsAgents, CODEX_IDENTITY_DIR, agentRenderFiles } from './chunk-V4OXHEWY.js';
 import { isScaffoldBody, isScaffoldDescription } from './chunk-76FLBODK.js';
-import { resolveConfiguredHarnessName, FACTORY_SOURCE_URL, GLOBAL_INSTALL_DIR_NAME, resolveLibraryDir, buildLibraryLockEntries, writeLock, computeHash, buildLockFile, readLock, assertLockHashes, verifyLock, mergeLockFile, resyncLockSources, extractForPatch, generatePatch, savePatch, applyPatch, LOCK_SCHEMA_VERSION } from './chunk-BRK5QZKI.js';
-import { resolveRuntimeAssets, factoryAssetRoots } from './chunk-QPWR3YMY.js';
+import { resolveConfiguredHarnessName, FACTORY_SOURCE_URL, GLOBAL_INSTALL_DIR_NAME, resolveLibraryDir, buildLibraryLockEntries, writeLock, computeHash, buildLockFile, readLock, assertLockHashes, verifyLock, mergeLockFile, resyncLockSources, extractForPatch, generatePatch, savePatch, applyPatch, LOCK_SCHEMA_VERSION } from './chunk-ABVWUM2E.js';
+import { resolveRuntimeAssets, factoryAssetRoots } from './chunk-3ENE6ZOF.js';
 import { deployedBase, isDeployed, deployedPaths, deployedDir } from './chunk-5KRMNUL4.js';
-import { resolveSkWorkspaceConfig, effectiveAgentInstances, mcpDeclarationFromMdContent, loadMcpServerDeclarations, resolveGlobalHarnesses, resolveGlobalSkWorkspaceConfig, getGlobalCacheDir, sourceCacheKey, getRepoCommit, matchPin, buildProvenanceIndex, coerceVersion, sourceShortName, readLinks, isCommitOnRemote, findWorkspaceRoot, resolveAll, agentSourceCacheDir, ensureRepo, resolveAgentDefinitionDir, scanRepo, SKAILE_YAML_DEFAULT, checkRepoStatus, resolveAsset, MAX_PRESET_DEPTH, PresetDepthError, DEFAULT_AGENT_INSTANCE_ID } from './chunk-KJSC2ZD6.js';
+import { resolveSkWorkspaceConfig, effectiveAgentInstances, mcpDeclarationFromMdContent, loadMcpServerDeclarations, resolveGlobalHarnesses, resolveGlobalSkWorkspaceConfig, getGlobalCacheDir, sourceCacheKey, getRepoCommit, matchPin, buildProvenanceIndex, coerceVersion, sourceShortName, readLinks, isCommitOnRemote, findWorkspaceRoot, resolveAll, agentSourceCacheDir, ensureRepo, resolveAgentDefinitionDir, scanRepo, SKAILE_YAML_DEFAULT, checkRepoStatus, resolveAsset, MAX_PRESET_DEPTH, PresetDepthError, DEFAULT_AGENT_INSTANCE_ID } from './chunk-6WQGJF65.js';
 import { globalSkaileDir, globalCacheRoot, migrateLegacyDir } from './chunk-L5VSIPQD.js';
 import { HARNESS_TARGETS, SUPPORTED_HARNESSES } from './chunk-VTETQCR6.js';
-import { listAssetFiles, loadSkPublishManifest, decodeSkaileManifest, isNonAssetDir, isNonAssetFile } from './chunk-KPKGWXUJ.js';
-import { scanDirectory, parseFrontmatter, parseRequires, dedupeRequirements, readAssetBody } from './chunk-JMIKGAUA.js';
+import { listAssetFiles, loadSkPublishManifest, decodeSkaileManifest, isNonAssetDir, isNonAssetFile } from './chunk-U6S5CXKB.js';
+import { scanDirectory, parseFrontmatter, parseRequires, dedupeRequirements, readAssetBody } from './chunk-VV2DJT4I.js';
 import { parseAssetRef, parseAssetRefLoose, assetRefToStr, slugifyAssetName, depToStr, parseDep } from './chunk-IZQOO6MN.js';
 import { spawnSync } from 'child_process';
 import { existsSync, rmSync, readFileSync, writeFileSync, readdirSync, lstatSync, statSync, unlinkSync, mkdirSync } from 'fs';
@@ -128,10 +128,18 @@ function removeAgentInstanceRenderings(opts) {
   }
   return removed;
 }
+function readInstanceFile(abs) {
+  try {
+    return statSync(abs).isDirectory() ? "\0dir" : readFileSync(abs, "utf-8");
+  } catch {
+    return void 0;
+  }
+}
 function installAgentInstances(opts) {
   const { projectDir, harness, log } = opts;
   const result = {
     instances: [],
+    changed: [],
     removed: [],
     warnings: [],
     errors: []
@@ -151,6 +159,9 @@ function installAgentInstances(opts) {
       if (previous[id]) owned[id] = previous[id];
       continue;
     }
+    const before = /* @__PURE__ */ new Map();
+    for (const rel of previous[id] ?? [])
+      before.set(rel, readInstanceFile(resolve(projectDir, rel)));
     const rendered = installAgent(
       srcDir,
       agentDeployDir,
@@ -169,6 +180,13 @@ function installAgentInstances(opts) {
     const files = [...new Set(rendered.created)];
     owned[id] = files;
     result.instances.push({ id, files });
+    const sameFiles = files.length === before.size && files.every((rel) => before.has(rel));
+    if (!sameFiles || files.some((rel) => {
+      const old = before.get(rel);
+      return old === void 0 || readInstanceFile(resolve(projectDir, rel)) !== old;
+    })) {
+      result.changed.push(id);
+    }
   }
   const claimed = new Set(Object.values(owned).flat());
   const root = resolve(projectDir);
@@ -1920,6 +1938,7 @@ var AssetManager = class {
       for (const w of [...result.warnings, ...result.errors]) console.warn(`skaile: ${w}`);
       return {
         agentInstances: result.instances,
+        agentInstancesChanged: result.changed,
         agentFilesRemoved: result.removed,
         ...result.errors.length > 0 ? { agentInstanceErrors: result.errors } : {},
         ...details.length > 0 ? { agentInstanceDetails: details } : {}
@@ -2952,6 +2971,30 @@ var AssetManager = class {
       })
     );
   }
+  /**
+   * Whether every declared ref is locked and no declared pin differs from the locked version:
+   * `skaile.yaml` asks for nothing the lock does not hold. A declared preset counts when the
+   * lock records it.
+   */
+  declaredMatchesLock(lock, declared) {
+    const keys = Object.keys(lock.assets).map((key) => parseCanonicalLockKey(key));
+    for (const d of declared) {
+      const want = parseRefTolerant(d.split(" ")[0] ?? d);
+      if (!want) return false;
+      if (want.kind === "preset") {
+        if (!this.presetRecorded(want)) return false;
+        continue;
+      }
+      const held = keys.filter(
+        (id) => id.kind === want.kind && id.name === want.name && (!want.publisher || !id.publisher || id.publisher === want.publisher)
+      );
+      if (held.length === 0) return false;
+      if (want.pin && !held.some((id) => !id.version || matchPin(want.pin, id.version))) {
+        return false;
+      }
+    }
+    return true;
+  }
   /**
    * Lock keys that `skaile.yaml` still wants: the entries a declared ref names, plus every
    * entry such an asset requires, transitively. All keys when a `preset:` is declared.
@@ -2985,7 +3028,12 @@ var AssetManager = class {
    * assets on this machine (not registered, or registered with its directory gone). Plain
    * `install` stops on a non-empty list, the same lines `install --locked` prints: it must
    * not re-resolve a locked asset from another origin. The ONE function that decides "the
-   * locked library is not here", so a lock-recorded URL fallback extends it in one place.
+   * locked library is not here", so a store-restore fallback extends it in one place.
+   *
+   * An entry `install --locked` already restored from a store (its library is not registered
+   * here and the store cache holds the locked version, see {@link restoredFromStoreCache}) is no
+   * line: it is returned in `restored`, and plain `install` then restores the lock as
+   * `install --locked` does instead of re-resolving it from another origin (OQ8, p1655).
    *
    * Only entries `skaile.yaml` still declares, or that a declared asset requires
    * (transitively, read from the deployed copy), count. A stale entry nothing declares is
@@ -3000,21 +3048,26 @@ var AssetManager = class {
     const locked = Object.entries(lock.assets).filter(
       ([key, e]) => e.library !== void 0 && !e.library.installed && inScope.has(key)
     );
-    if (locked.length === 0) return [];
-    const snap = await this.loadLibraryIndex();
     const lines = [];
+    const restored = [];
+    if (locked.length === 0) return { lines, restored };
+    const snap = await this.loadLibraryIndex();
     for (const [ref, e] of locked) {
       const { publisher, kind, name } = parseCanonicalLockKey(ref);
       if (!publisher || !kind || !name) continue;
       const lookup = this.lockedLibrary(e.library, snap, { kind, publisher, name });
       if (lookup.state === "ok") continue;
+      if (await this.restoredFromStoreCache(ref, e, snap)) {
+        restored.push(ref);
+        continue;
+      }
       const component = this.installTarget(kind);
       const deployed = component !== void 0 && isDeployed(component, name, this.harness, this.global, this.projectDir);
       const problem = lockedLibraryProblem(lookup, e.library, `${kind}:@${publisher}/${name}`);
       const kept = deployed ? "the deployed copy and its lock entry are kept" : "its lock entry is kept; no deployed copy exists";
       lines.push(`${ref} (${problem}; ${kept})`);
     }
-    return lines;
+    return { lines, restored };
   }
   /**
    * Re-resolve every library-origin lock entry from its named library, for
@@ -3023,17 +3076,21 @@ var AssetManager = class {
    * version; anything else is reported in `missing` with the reason.
    *
    * @param opts.storeFallback - `install --locked` only: an entry whose library is not registered
-   *   here is restored from a store that serves the locked sha256 (OQ15, p1490). Reads such as
-   *   the drift check never ask a store.
+   *   here is restored from a store that serves the locked sha256 (OQ8, OQ15, p1490, p1655). The
+   *   lock records the library's remote and hash but no commit and no file list, so the library
+   *   remote itself cannot be fetched at a locked commit; the store pointer names the upstream
+   *   repository and commit that hold exactly the hashed bytes. Reads such as the drift check
+   *   never ask a store.
    */
   async restoreLibraryLockEntries(lock, opts) {
     const entries = [];
     const missing = [];
     const viaStore = [];
+    const storeOrigins = {};
     const locked = Object.entries(lock.assets).filter(
       ([, e]) => e.library !== void 0 && !e.library.installed
     );
-    if (locked.length === 0) return { entries, missing, viaStore };
+    if (locked.length === 0) return { entries, missing, viaStore, storeOrigins };
     const snap = await this.loadLibraryIndex();
     const diskHashes = /* @__PURE__ */ new Map();
     const fileSets = /* @__PURE__ */ new Map();
@@ -3048,8 +3105,9 @@ var AssetManager = class {
       if (lookup.state !== "ok") {
         const fallback = lookup.state === "unregistered" && opts?.storeFallback ? await this.storeEntryForLockedLibraryAsset(publisher, kind, name, origin) : null;
         if (fallback) {
-          entries.push(fallback);
+          entries.push(fallback.entry);
           viaStore.push(ref);
+          storeOrigins[ref] = fallback.from;
           continue;
         }
         missing.push(
@@ -3094,17 +3152,21 @@ var AssetManager = class {
       found.version = sameVersion ? origin.version : current;
       entries.push(withLibraryFiles(found, libPath, fileSets, this.registry));
     }
-    return { entries, missing, viaStore };
+    return { entries, missing, viaStore, storeOrigins };
   }
   /**
-   * Whether a library-origin lock entry was restored from its lock url: its library is not
+   * Whether a library-origin lock entry was restored from a store: its library is not
    * registered here, and the project's store cache holds the locked version (`install --locked`
-   * fetched and SHA-verified it there against the sha256 the lock recorded). Such an entry is
-   * as restorable as a source- or store-origin one: `check` and `doctor` read its requirements
-   * from the deployed copy and do not ask for the library (OQ8, p1655). An unregistered library
-   * that never restored anything here stays a gap.
+   * fetched it there and SHA-verified every file against the sha256 the lock recorded). Such an
+   * entry is as restorable as a source- or store-origin one: `check`, `doctor` and plain
+   * `install` read its requirements from the deployed copy and do not ask for the library (OQ8,
+   * p1655). An unregistered library that never restored anything here stays a gap.
+   *
+   * This only checks that the cache directory of the locked version is not empty: the bytes were
+   * verified when they were fetched, and a later edit of the deployed copy is the `modified`
+   * drift check's job, not this one's.
    */
-  async restoredFromLockUrl(key, entry, snap) {
+  async restoredFromStoreCache(key, entry, snap) {
     const origin = entry.library;
     if (!origin || origin.installed || !origin.sha256 || !origin.version) return false;
     if (isPseudoVersion(origin.version)) return false;
@@ -3124,7 +3186,8 @@ var AssetManager = class {
    * store (project `stores:` or the global catalog) that serves `kind:@publisher/name#version`
    * under the very sha256 the lock recorded holds the same bytes. The entry is fetched and
    * verified like any store asset; the lock stays as it is. `null` when the lock has no hash,
-   * no store answers, or the hash differs (OQ15, p1490).
+   * no store answers, or the hash differs (OQ15, p1490). `from` names the store and the
+   * upstream repository and commit its pointer gives, for the notice.
    */
   async storeEntryForLockedLibraryAsset(publisher, kind, name, origin) {
     if (!origin.sha256 || !origin.version || isPseudoVersion(origin.version)) return null;
@@ -3155,7 +3218,12 @@ var AssetManager = class {
           ],
           repositories
         );
-        if (entry) return entry;
+        if (entry) {
+          return {
+            entry,
+            from: `${store.url} (${sourceShortName(m.sourceUrl)}@${m.commit.slice(0, 7)})`
+          };
+        }
       } catch (err) {
         this.noteStoreFailure(store.url, err);
       }
@@ -3942,18 +4010,25 @@ var AssetManager = class {
       return this.installLocked(repositories, patches, dependencies);
     }
     const lockForLibraries = this.tryReadLock();
+    const restoredFromStore = /* @__PURE__ */ new Set();
     if (lockForLibraries) {
       const unavailable = await this.unavailableLockedLibraries(lockForLibraries, dependencies);
-      if (unavailable.length > 0) {
+      for (const key of unavailable.restored) restoredFromStore.add(key);
+      if (unavailable.lines.length > 0) {
         return {
           deployed: [],
           removed: [],
-          missing: unavailable,
+          missing: unavailable.lines,
           lockWritten: false,
           npmInstalled: [],
           npmFailed: []
         };
       }
+      if (unavailable.restored.length > 0 && this.declaredMatchesLock(lockForLibraries, dependencies) && [...await this.declaredLockKeys(lockForLibraries, dependencies)].every(
+        (key) => restoredFromStore.has(key)
+      )) {
+        return this.installLocked(repositories, patches, dependencies);
+      }
       const orphans = await this.orphanedSourceGaps(
         await this.declaredLockKeys(lockForLibraries, dependencies),
         true
@@ -4070,6 +4145,27 @@ var AssetManager = class {
     const entries = [...await this.buildCatalogEntries(resolved, repositories), ...lib.entries];
     assertFlowsLoad(entries, "installed");
     assertNoLibrarySymlinks(entries, this.registry, repositories, opts?.link === true);
+    if (libraryAssetCheck && lib.entries.length > 0) {
+      const lockedIds = new Set([...lockedKeys].map((k) => k.split("#")[0]));
+      const snap = await this.loadLibraryIndex();
+      for (const e of lib.entries) {
+        if (lockedIds.has(canonicalEntryRef(e).split("#")[0])) continue;
+        const origin = lib.libraryOf.get(e);
+        const libPath = origin ? this.libraryPath({ name: origin }, snap) : null;
+        if (!origin || !libPath || !e.source) continue;
+        const lines = libraryAssetCheck(
+          { kind: e.kind, name: e.name, source: e.source },
+          libPath
+        ).filter((l) => /placeholder/i.test(l));
+        if (lines.length > 0) {
+          throw new Error(
+            `${canonicalEntryRef(e)} in library "${origin}" fails the checks of \`skaile validate\` - nothing was installed:
+${lines.map((l) => `  ${l}`).join("\n")}
+Fix the asset, then run \`skaile library index ${origin}\` and install again.`
+          );
+        }
+      }
+    }
     const forceCommand = opts?.moveLibraries === true ? "skaile update --force" : "skaile install --force";
     if (!opts?.force) {
       await this.assertNoHandEditsPruned(
@@ -4147,8 +4243,15 @@ var AssetManager = class {
     }
     this.recordInstallHistory(deployed, removed);
     const { npmInstalled, npmFailed } = await this.installRuntimeAssetDeps();
-    const reportedMissing = stillMissing.filter((m) => !storeNotChecked.some((n) => n.ref === m));
+    const restoredRefs = stillMissing.filter((m) => {
+      const keys = kept.keysByRef.get(m) ?? [];
+      return keys.length > 0 && keys.every((k) => restoredFromStore.has(k));
+    });
+    const reportedMissing = stillMissing.filter(
+      (m) => !storeNotChecked.some((n) => n.ref === m) && !restoredRefs.includes(m)
+    );
     for (const n of storeNotChecked) delete missingHints[n.ref];
+    for (const m of restoredRefs) delete missingHints[m];
     await this.adviseMissing(reportedMissing, missingHints);
     const placeholderBodies = scaffoldBodyRefs(lib.entries, deployed);
     const placeholderDescriptions = scaffoldDescriptionRefs(lib.entries, deployed);
@@ -4564,7 +4667,11 @@ Nothing was changed. Move your edits away, or run \`${forceCommand}\` to overwri
         ).split(sep).join("/");
         files = files.map((f) => `${dir}/${f}`);
       }
-      if (files.length > 0) lines.push(`${d.ref} (${files.join(", ")} was edited)`);
+      if (files.length > 0) {
+        lines.push(
+          d.unrecorded ? `${d.ref} (${files.join(", ")} differs from the library's content now; the lock keeps no per-file record, so it may be a library change, not your edit)` : `${d.ref} (${files.join(", ")} was edited)`
+        );
+      }
     }
     if (lines.length === 0) return;
     throw new Error(
@@ -4939,7 +5046,7 @@ Nothing was changed. Copy your edits away, or run \`${forceCommand}\` to replace
       const p = parseRefTolerant(g.ref);
       return !(p && alreadyMissing.has(`${p.kind}:${p.name}`));
     }).map((g) => g.message);
-    const libraryNotices = this.lockUrlRestoreNotices(lock, library.viaStore);
+    const libraryNotices = this.storeRestoreNotices(lock, library.viaStore, library.storeOrigins);
     const placeholderBodies = scaffoldBodyRefs(library.entries, deployed);
     const placeholderDescriptions = scaffoldDescriptionRefs(library.entries, deployed);
     return {
@@ -4958,22 +5065,31 @@ Nothing was changed. Copy your edits away, or run \`${forceCommand}\` to replace
   }
   /**
    * One notice line per locked library that is not registered here and whose assets
-   * `install --locked` restored from the lock url: names the library, how many assets came from
-   * the url, and how to register the library to move the lock later (OQ8, p1655).
+   * `install --locked` restored from a store: names the library, how many assets came from
+   * which store (and the upstream repository and commit its pointer names), and how to register
+   * the library to move the lock later (OQ8, p1655). Every file was SHA-verified against the
+   * hash the lock recorded.
    */
-  lockUrlRestoreNotices(lock, viaStore) {
+  storeRestoreNotices(lock, viaStore, storeOrigins) {
     const byLibrary = /* @__PURE__ */ new Map();
     for (const key of viaStore) {
       const origin = lock.assets[key]?.library;
       if (!origin) continue;
       const name = unregisteredLibraryName(origin);
-      const row = byLibrary.get(name) ?? { ...origin.url ? { url: origin.url } : {}, refs: [] };
+      const row = byLibrary.get(name) ?? {
+        ...origin.url ? { url: origin.url } : {},
+        refs: [],
+        from: /* @__PURE__ */ new Set()
+      };
       row.refs.push(key);
+      const from = storeOrigins[key];
+      if (from) row.from.add(from);
       byLibrary.set(name, row);
     }
-    return [...byLibrary].map(([name, { url, refs }]) => {
+    return [...byLibrary].map(([name, { url, refs, from }]) => {
       const register = url ? `skaile library init ${name} --git ${url}` : `skaile library init ${name} --path <dir>`;
-      return `Library "${name}" is not registered here: restored ${refs.length} asset${refs.length === 1 ? "" : "s"} from the lock url${url ? ` ${url}` : ""}. Register it with \`${register}\` to move the lock later.`;
+      const where = from.size > 0 ? ` from the store ${[...from].join(", ")}` : " from a store";
+      return `Library "${name}" is not registered here: restored ${refs.length} asset${refs.length === 1 ? "" : "s"}${where}, every file checked against the lock. Register it with \`${register}\` to move the lock later.`;
     });
   }
   /**
@@ -7500,7 +7616,7 @@ Fix the asset in the source repo, then run \`skaile source sync\` and add it aga
             break;
           }
           librarySnap ??= { snap: await this.loadLibraryIndex() };
-          if (await this.restoredFromLockUrl(key, e, librarySnap.snap)) {
+          if (await this.restoredFromStoreCache(key, e, librarySnap.snap)) {
             restorable = true;
             break;
           }
@@ -7702,11 +7818,15 @@ Fix the asset in the source repo, then run \`skaile source sync\` and add it aga
       named.add(gapIdentity(ref));
     }
     for (const d of await this.lockedCopyDrift()) {
-      if (named.has(gapIdentity(d.ref))) continue;
+      if (named.has(gapIdentity(d.ref))) {
+        const at = d.libraryChanged ? gaps.findIndex((g) => g.type === "content" && gapIdentity(g.ref) === gapIdentity(d.ref)) : -1;
+        if (at < 0) continue;
+        gaps.splice(at, 1);
+      }
       const parts = [
         ...d.modified.map((f) => {
           const instance = d.instanceOf?.get(f);
-          return instance ? `${f}, the file of agent instance "${instance}", was edited` : `${f} was edited`;
+          return instance ? `${f}, the file of agent instance "${instance}", was edited` : d.unrecorded ? `${f} differs from the library's content now (the lock keeps no per-file record: it may be a library change, not your edit)` : `${f} was edited`;
         }),
         ...d.extra.map((f) => `${f} is not part of the asset`)
       ];
@@ -7995,7 +8115,7 @@ Fix the asset in the source repo, then run \`skaile source sync\` and add it aga
         continue;
       }
       if (lookup.state === "unregistered") {
-        if (await this.restoredFromLockUrl(key, entry, snap)) continue;
+        if (await this.restoredFromStoreCache(key, entry, snap)) continue;
         const reason2 = `is locked, but library "${unregisteredLibraryName(origin)}" is not registered (renamed or removed?) \u2014 ${unregisteredLibraryFix(origin, ref)}`;
         gaps.push({ type: "library", ref, reason: reason2, message: `${ref} ${reason2}`, manualFix: true });
         continue;
@@ -8439,7 +8559,15 @@ Fix the asset in the source repo, then run \`skaile source sync\` and add it aga
         })?.modified ?? [];
       }
       if (modified.length > 0) {
-        out.push({ ref, key, modified, extra: [], library: true, libraryChanged: true });
+        out.push({
+          ref,
+          key,
+          modified,
+          extra: [],
+          library: true,
+          libraryChanged: true,
+          ...entry.copied && entry.copied.length > 0 ? {} : { unrecorded: true }
+        });
       }
     }
     return out;
@@ -8487,15 +8615,10 @@ Fix the asset in the source repo, then run \`skaile source sync\` and add it aga
       const ref = `${e.kind}:@${(e.publisher ?? "").replace(/^@/, "")}/${e.name}`;
       out.push({ ref, key: keyOf.get(ref) ?? ref, ...drift, library: true });
     }
-    out.push(
-      ...await this.changedLibraryCopyEdits(
-        lock,
-        new Set(
-          entries.map((e) => `${e.kind}:@${(e.publisher ?? "").replace(/^@/, "")}/${e.name}`)
-        ),
-        patches
-      )
+    const restoredRefs = new Set(
+      entries.map((e) => `${e.kind}:@${(e.publisher ?? "").replace(/^@/, "")}/${e.name}`)
     );
+    out.push(...await this.changedLibraryCopyEdits(lock, restoredRefs, patches));
     for (const [key, entry] of Object.entries(lock.assets)) {
       if (!entry.source || entry.files.length === 0) continue;
       const { kind, name } = parseCanonicalLockKey(key);
@@ -8529,6 +8652,7 @@ Fix the asset in the source repo, then run \`skaile source sync\` and add it aga
       if (modified.length > 0 || extra.length > 0)
         out.push({ ref: refOf(key), key, modified, extra, library: false });
     }
+    let snapForAgents;
     for (const [key, entry] of Object.entries(lock.assets)) {
       const recorded = [...entry.rendered ?? [], ...entry.composed ?? []];
       if (recorded.length === 0 || entry.library?.installed) continue;
@@ -8550,12 +8674,24 @@ Fix the asset in the source repo, then run \`skaile source sync\` and add it aga
         for (const inst of renderedInstanceFiles(this.projectDir, this.harness)) {
           for (const f of inst.files) if (modified.includes(f)) instanceOf.set(f, inst.id);
         }
+        let libraryChanged = false;
+        const origin = entry.library;
+        const id = parseCanonicalLockKey(key);
+        if (origin && id.publisher && !restoredRefs.has(refOf(key))) {
+          snapForAgents ??= await this.loadLibraryIndex();
+          libraryChanged = this.lockedLibrary(origin, snapForAgents, {
+            kind,
+            publisher: id.publisher,
+            name
+          }).state === "ok";
+        }
         out.push({
           ref: refOf(key),
           key,
           modified,
           extra: [],
           library: false,
+          ...libraryChanged ? { libraryChanged: true } : {},
           rendered: true,
           lockedSha: new Map(recorded.map((f) => [f.path, f.sha256])),
           instanceOf
@@ -9167,5 +9303,5 @@ Fix the asset in the source repo, then run \`skaile source sync\` and add it aga
 };
 
 export { AssetManager, LibraryEntryError, MissingManifestError, installAgentInstances, labelDiffHeaders, mcpNotRunnableReason, normalizeRepoUrl, parseCanonicalLockKey, parseRefTolerant, renderMcpServerConfig, setLibraryAssetCheck, setRenamedEntryLookup, softDepName };
-//# sourceMappingURL=chunk-PKBLJI23.js.map
-//# sourceMappingURL=chunk-PKBLJI23.js.map
+//# sourceMappingURL=chunk-TGB4E5Z6.js.map
+//# sourceMappingURL=chunk-TGB4E5Z6.js.map