@skaile/workspaces 5.13.0 → 5.15.0

package/dist/{chunk-Y7WKXPWS.js → chunk-XX4C72CC.js}

@@ -1,23 +1,24 @@
-import { unregisteredLibraryNames, renamedLibraryName, resolveConfig, RemoteCatalogSource, OfflineError, describeCatalogError, CatalogHttpError, scanUnlistedAssets, getStoreManifestsDir, missingLibraryDirMessage } from './chunk-DKGEV6SQ.js';
-import { readManifestSourceConfig, discoverAssetsInTree, isManifestMode } from './chunk-NVO6WECE.js';
-import { installTargetOf, canonicalEntryRef, deployedAssetDrift, deployAll, removeAsset, diffDeployedAgent, createScaffold, installAgent } from './chunk-5FYOM4RF.js';
+import { unregisteredLibraryNames, renamedLibraryName, resolveConfig, RemoteCatalogSource, OfflineError, describeCatalogError, CatalogHttpError, scanUnlistedAssets, getStoreManifestsDir, missingLibraryDirMessage } from './chunk-OOQ5Q75W.js';
+import { SEMVER_RE, readManifestSourceConfig, discoverAssetsInTree, isManifestMode } from './chunk-NKDSU4Q7.js';
+import { installTargetOf, canonicalEntryRef, deployedAssetDrift, deployAll, removeAsset, diffDeployedAgent, createScaffold, installAgent } from './chunk-WWUWMOX2.js';
 import { appendHistory, getRecentHistory, clearHistory } from './chunk-KTBKW2FI.js';
 import { commitChanges } from './chunk-UQ6LFBPZ.js';
-import { driverTargetSupportsAgents, CODEX_IDENTITY_DIR } from './chunk-4L4R5LV3.js';
-import { resolveConfiguredDriverTarget, GLOBAL_INSTALL_DIR_NAME, resolveLibraryDir, buildLibraryLockEntries, computeHash, buildLockFile, writeLock, readLock, verifyLock, mergeLockFile, extractForPatch, generatePatch, savePatch, applyPatch, LOCK_SCHEMA_VERSION } from './chunk-BF422IDP.js';
-import { resolveRuntimeAssets, factoryAssetRoots } from './chunk-QO7CR3KB.js';
+import { driverTargetSupportsAgents, CODEX_IDENTITY_DIR } from './chunk-BV7NLPI6.js';
+import { resolveConfiguredDriverTarget, GLOBAL_INSTALL_DIR_NAME, resolveLibraryDir, buildLibraryLockEntries, computeHash, buildLockFile, writeLock, readLock, verifyLock, mergeLockFile, extractForPatch, generatePatch, savePatch, applyPatch, LOCK_SCHEMA_VERSION } from './chunk-4QINFQ27.js';
+import { resolveRuntimeAssets, factoryAssetRoots } from './chunk-X7DIT65W.js';
 import { deployedBase, deployedDir, isDeployed, deployedPaths } from './chunk-D54T2F54.js';
-import { resolveSkWorkspaceConfig, effectiveAgentInstances, loadMcpServerDeclarations, resolveGlobalHarnesses, resolveGlobalSkWorkspaceConfig, getGlobalCacheDir, sourceCacheKey, getRepoCommit, matchPin, buildProvenanceIndex, coerceVersion, sourceShortName, readLinks, isCommitOnRemote, resolveAll, agentSourceCacheDir, ensureRepo, scanRepo, SKAILE_YAML_DEFAULT, checkRepoStatus, resolveAsset, MAX_PRESET_DEPTH, PresetDepthError, DEFAULT_AGENT_INSTANCE_ID, resolveAgentDefinitionDir, storeManifestSlug } from './chunk-L3ZGYSWY.js';
+import { resolveSkWorkspaceConfig, effectiveAgentInstances, loadMcpServerDeclarations, resolveGlobalHarnesses, resolveGlobalSkWorkspaceConfig, getGlobalCacheDir, sourceCacheKey, getRepoCommit, matchPin, buildProvenanceIndex, coerceVersion, sourceShortName, readLinks, isCommitOnRemote, resolveAll, agentSourceCacheDir, ensureRepo, scanRepo, SKAILE_YAML_DEFAULT, checkRepoStatus, resolveAsset, MAX_PRESET_DEPTH, PresetDepthError, DEFAULT_AGENT_INSTANCE_ID, resolveAgentDefinitionDir, storeManifestSlug } from './chunk-J76LDUDS.js';
 import { globalSkaileDir, globalCacheRoot, migrateLegacyDir } from './chunk-L5VSIPQD.js';
 import { DRIVER_TARGETS } from './chunk-IG5LZ3WU.js';
-import { loadSkPublishManifest } from './chunk-IY5E7Y5W.js';
-import { scanDirectory, parseFrontmatter, parseRequires, dedupeRequirements } from './chunk-M3P4BYRK.js';
-import { parseAssetRef, parseAssetRefLoose, assetRefToStr, slugifyAssetName, depToStr, parseDep } from './chunk-J4OYIYFQ.js';
+import { loadSkPublishManifest } from './chunk-ANSZULXH.js';
+import { scanDirectory, parseFrontmatter, parseRequires, dedupeRequirements } from './chunk-SP5NGNBV.js';
+import { parseAssetRef, parseAssetRefLoose, assetRefToStr, slugifyAssetName, depToStr, parseDep } from './chunk-VY6NTFE7.js';
 import { spawnSync } from 'child_process';
-import { existsSync, rmSync, readdirSync, lstatSync, readFileSync, unlinkSync, mkdirSync, writeFileSync } from 'fs';
+import { existsSync, rmSync, readdirSync, readFileSync, lstatSync, unlinkSync, mkdirSync, writeFileSync } from 'fs';
 import path, { resolve, dirname, sep, join, relative, posix } from 'path';
 import { gt } from 'semver';
-import { stringify, parse } from 'yaml';
+import { parse, stringify } from 'yaml';
+import { createHash } from 'crypto';
 import fs from 'fs/promises';
 
 var ledgerPath = (projectDir) => join(projectDir, ".skaile", "agent-instances-managed.json");
@@ -37,6 +38,31 @@ function writeLedger(projectDir, ledger) {
   writeFileSync(p, `${JSON.stringify(ledger, null, 2)}
 `, "utf-8");
 }
+function renderedInstanceFiles(projectDir, driverTarget) {
+  const recorded = readLedger(projectDir).targets[driverTarget];
+  if (!recorded) return [];
+  let instances;
+  try {
+    instances = effectiveAgentInstances(resolveSkWorkspaceConfig(projectDir));
+  } catch {
+    return [];
+  }
+  return Object.entries(instances).filter(([id]) => recorded[id]?.length).map(([id, instance]) => ({ id, ref: instance.ref, files: recorded[id] }));
+}
+function instanceRenderedAgentNames(projectDir, driverTarget) {
+  const names = /* @__PURE__ */ new Set();
+  if (!driverTargetSupportsAgents(driverTarget)) return names;
+  const agentDir = resolve(deployedBase("agent", driverTarget, false, projectDir));
+  for (const files of Object.values(readLedger(projectDir).targets[driverTarget] ?? {})) {
+    for (const rel of files) {
+      const abs = resolve(projectDir, rel);
+      if (!abs.startsWith(agentDir + sep)) continue;
+      const top = abs.slice(agentDir.length + 1).split(sep)[0] ?? "";
+      if (top) names.add(top.replace(/\.(md|toml|yaml|json)$/, ""));
+    }
+  }
+  return names;
+}
 function bindInstance(projectDir, id, instance) {
   const errors = [];
   let srcDir;
@@ -177,6 +203,8 @@ var UNSUPPORTED_SECRET_PREFIXES = [
   "connector:",
   "mcp:"
 ];
+var TEMPLATE_PLACEHOLDER = /<[^<>\s/]+>/;
+var PAYLOAD_FETCH_TIMEOUT_MS = 6e4;
 var WORKSPACE_MARKER = /\$\{workspace\}/g;
 function substituteWorkspace(value, projectDir) {
   return value.replace(WORKSPACE_MARKER, projectDir);
@@ -207,10 +235,90 @@ function skipReason(decl) {
   const transport = decl.transport ?? "stdio";
   if (transport === "stdio" && !decl.command) return "no command";
   if (transport !== "stdio" && !decl.url) return "no url";
+  const placeholder = decl.url ? TEMPLATE_PLACEHOLDER.exec(decl.url)?.[0] : void 0;
+  if (placeholder) {
+    return `its url still holds the placeholder ${placeholder} \u2014 set the real value with an mcp_servers entry (id: ${decl.id}, url: ...) in skaile.yaml`;
+  }
   const badRef = findUnsupportedSecretRef(decl);
   if (badRef) return `unsupported secret reference '${badRef}'`;
   return void 0;
 }
+function payloadDir(projectDir, id) {
+  const name = id.split("/").pop() ?? id;
+  if (!isPlainName(name)) return void 0;
+  return path.join(projectDir, ".skaile", "assets", "mcp-server", name);
+}
+function isPlainName(name) {
+  return name !== "" && name !== "." && name !== ".." && !/[/\\\0]/.test(name) && !path.isAbsolute(name) && !path.win32.isAbsolute(name);
+}
+function decodeSegment(segment) {
+  try {
+    return decodeURIComponent(segment);
+  } catch {
+    return void 0;
+  }
+}
+async function defaultFetchPayload(url) {
+  const res = await fetch(url, {
+    redirect: "follow",
+    signal: AbortSignal.timeout(PAYLOAD_FETCH_TIMEOUT_MS)
+  });
+  if (!res.ok) throw new Error(`${url} answered ${res.status}`);
+  return new Uint8Array(await res.arrayBuffer());
+}
+async function ensurePayload(projectDir, decl, fetchPayload) {
+  const payload = decl.payload;
+  if (!payload) return void 0;
+  let dest = payload.dest;
+  if (dest === void 0) {
+    try {
+      dest = decodeSegment(new URL(payload.url).pathname.split("/").pop() ?? "");
+    } catch {
+      dest = void 0;
+    }
+  }
+  if (dest === void 0 || !isPlainName(dest)) {
+    return `payload ${payload.url} has no usable file name (${JSON.stringify(dest ?? "")}): a plain file name is required`;
+  }
+  const dir = payloadDir(projectDir, decl.id);
+  if (!dir) return `payload of '${decl.id}' has no usable directory name`;
+  const file = path.join(dir, dest);
+  const sha = (bytes2) => createHash("sha256").update(bytes2).digest("hex");
+  try {
+    if (sha(await fs.readFile(file)) === payload.sha256) return void 0;
+  } catch {
+  }
+  let bytes;
+  try {
+    bytes = await fetchPayload(payload.url);
+  } catch (err) {
+    const why = err.cause?.code ?? (err instanceof Error ? err.message : String(err));
+    return `payload ${payload.url} could not be fetched (${why})`;
+  }
+  const actual = sha(bytes);
+  if (actual !== payload.sha256) {
+    return `payload ${payload.url} has sha256 ${actual}, not the pinned ${payload.sha256}; it was not written`;
+  }
+  try {
+    await fs.mkdir(dir, { recursive: true });
+    const tmp = `${file}.${process.pid}.tmp`;
+    await fs.writeFile(tmp, bytes);
+    await fs.rename(tmp, file);
+  } catch (err) {
+    return `payload ${dest} could not be written: ${err instanceof Error ? err.message : String(err)}`;
+  }
+  return void 0;
+}
+async function removePayloadDir(projectDir, id) {
+  const dir = payloadDir(projectDir, id);
+  if (!dir) return;
+  try {
+    await fs.access(path.join(dir, "MCP.md"));
+    return;
+  } catch {
+  }
+  await fs.rm(dir, { recursive: true, force: true });
+}
 function buildEntry(decl, projectDir) {
   const transport = decl.transport ?? "stdio";
   if (transport !== "stdio") {
@@ -294,7 +402,7 @@ async function renderMcpServerConfig(projectDir, driverTarget, opts) {
   const skipped = [];
   const renderable = /* @__PURE__ */ new Map();
   for (const decl of declarations) {
-    const reason = skipReason(decl);
+    const reason = skipReason(decl) ?? await ensurePayload(projectDir, decl, opts?.fetchPayload ?? defaultFetchPayload);
     if (reason) {
       skipped.push({ id: decl.id, reason });
       warn(`MCP server "${decl.id}" not written to ${relConfig}: ${reason}`);
@@ -316,6 +424,7 @@ async function renderMcpServerConfig(projectDir, driverTarget, opts) {
     warn,
     relConfig
   );
+  for (const id of removed) await removePayloadDir(projectDir, id);
   const ledgerStale = JSON.stringify(owned) !== JSON.stringify(managedIds);
   if (ledgerStale) await writeManagedIds(projectDir, driverTarget, owned);
   if (Object.keys(next).length === 0 && !existingFile) {
@@ -658,7 +767,7 @@ function parseRefTolerant(ref) {
   }
 }
 function keptLockEntries(prev, missing) {
-  const out = { assets: {}, sources: [], refs: /* @__PURE__ */ new Set() };
+  const out = { assets: {}, sources: [], refs: /* @__PURE__ */ new Set(), keysByRef: /* @__PURE__ */ new Map() };
   if (!prev) return out;
   for (const ref of missing) {
     const want = parseRefTolerant(ref.split(" ")[0] ?? ref);
@@ -670,6 +779,7 @@ function keptLockEntries(prev, missing) {
       if (want.publisher && id.publisher !== want.publisher) continue;
       out.assets[key] = entry;
       out.refs.add(ref);
+      out.keysByRef.set(ref, [...out.keysByRef.get(ref) ?? [], key]);
       const src = entry.source ? prev.sources.find((s) => s.url === entry.source?.url) : void 0;
       if (src) out.sources.push(src);
     }
@@ -836,6 +946,8 @@ var AssetManager = class {
   warnedStoreVersionLookups = /* @__PURE__ */ new Set();
   /** Stores a lookup could not reach (store URL -> one line why); `add` reports them instead of "not found". */
   storeFailures = /* @__PURE__ */ new Map();
+  /** Store URLs a lookup failed on because the client is air-gapped (`cache_ttl: 0`), not because the store is down. */
+  airGappedStores = /* @__PURE__ */ new Set();
   /** Sources a provenance walk had to skip (source URL → why); one warning per source. */
   skippedSources = /* @__PURE__ */ new Map();
   /** `onSourceError` of every provenance walk: name the source once, leave it out, go on. */
@@ -1222,6 +1334,11 @@ var AssetManager = class {
       } : void 0;
       candidates.sort(libraryPreference(isDefaultLib, prefer));
       const hit = candidates[0];
+      if (hit.entry.version && !SEMVER_RE.test(hit.entry.version)) {
+        throw new Error(
+          `${canonicalEntryRef(hit.entry)} (library ${hit.library}): version "${hit.entry.version}" is not valid semver. Set a valid version in the asset file and run \`skaile library index ${hit.library}\`.`
+        );
+      }
       if (!opts.quiet && !opts.library) {
         this.warnLibraryCollision(
           `${hit.entry.kind}:@${hit.entry.publisher}/${hit.entry.name}`,
@@ -1538,14 +1655,35 @@ var AssetManager = class {
       } else if (lookup.state === "unregistered") {
         out.set(ref, unregisteredLibraryFix(origin, plain));
       } else {
+        const renamedTo = await this.renamedFlowRef(lookup, want.publisher, want.kind, want.name);
         out.set(
           ref,
-          `library "${lookup.name}" no longer holds it \u2014 restore it there, or drop the dependency with \`skaile remove ${plain}\``
+          renamedTo ? `library "${lookup.name}" holds it as ${renamedTo} now (a flow is named by its \`id:\`) \u2014 run \`skaile remove ${plain}\`, then \`skaile add ${renamedTo}\`` : `library "${lookup.name}" no longer holds it \u2014 restore it there, or drop the dependency with \`skaile remove ${plain}\``
         );
       }
     }
     return out;
   }
+  /**
+   * The ref a library now holds a flow under when a project still locks it by the slug of the
+   * flow's `name:` (5.12.0 named a flow by `name:`; later releases name it by `id:`), or
+   * `undefined` when `kind` is no flow, the library is not at hand or no flow of it matches.
+   */
+  async renamedFlowRef(lookup, publisher, kind, name) {
+    if (kind !== "flow" || !publisher || lookup.state !== "ok") return void 0;
+    const scanned = await scanDirectory(lookup.path, publisher, { knownKinds: this.knownKinds });
+    for (const entry of scanned) {
+      if (entry.kind !== "flow" || entry.name === name) continue;
+      try {
+        const meta = parse(readFileSync(entry.source, "utf8"));
+        if (meta && typeof meta === "object" && "name" in meta && typeof meta.name === "string" && slugifyAssetName(meta.name) === name) {
+          return `flow:@${publisher}/${entry.name}`;
+        }
+      } catch {
+      }
+    }
+    return void 0;
+  }
   /** Collision messages already printed by this instance (one warning per ref + library set). */
   warnedLibraryCollisions = /* @__PURE__ */ new Set();
   /**
@@ -1894,7 +2032,10 @@ var AssetManager = class {
         (x) => x.kind === kind && x.name === name
       );
       if (!found) {
-        missing.push(`${ref} (not found in library "${lookup.name}")`);
+        const renamedTo = await this.renamedFlowRef(lookup, publisher, kind, name);
+        missing.push(
+          renamedTo ? `${ref} (library "${lookup.name}" holds it as ${renamedTo} now (a flow is named by its \`id:\`) \u2014 run \`skaile remove ${kind}:@${publisher}/${name}\`, then \`skaile add ${renamedTo}\`)` : `${ref} (not found in library "${lookup.name}")`
+        );
         continue;
       }
       const def = newestLibraryDef(snap, lookup.name, { kind, publisher, name });
@@ -2243,14 +2384,18 @@ var AssetManager = class {
       }
     }
   }
-  /** The catalog fetcher to use: an injected one, else built from `stores`. */
+  /**
+   * The catalog fetcher to use: an injected one, else built from `stores`. `catalogUrl: ""`
+   * (`update --no-catalog`) asks no store at all, project `stores:` included.
+   */
   storeFetcherFor(stores) {
-    return this.injectedStoreFetcher ?? this.buildStoreFetcher(stores);
+    if (this.injectedStoreFetcher) return this.injectedStoreFetcher;
+    return this.catalogUrlOverride === "" ? void 0 : this.buildStoreFetcher(stores);
   }
   /**
    * The global `catalog.url` as a single-store fallback, or `[]` when no
    * project store should be synthesized — `local` sentinel, already-declared,
-   * or no URL. Honours an explicit `catalogUrl` injection (`""` disables it).
+   * or no URL. Honours an explicit `catalogUrl` injection (`""` and `"local"` disable it).
    */
   async globalStoreFallback(projectStores) {
     let url = this.catalogUrlOverride;
@@ -2466,6 +2611,18 @@ var AssetManager = class {
       ...opts?.moveLibraries ? { preferLocked: await this.lockedPreference() } : { lockedLibraries: await this.lockedLibraryNames() }
     });
     this.assertNoFolderCollision([...resolved, ...lib.entries.map((e) => this.entryIdentity(e))]);
+    if (!opts?.force && !(existsSync(this.lockPath) && this.tryReadLock() === null)) {
+      this.assertNoUnownedFolder(
+        [
+          ...resolved.map((c) => ({
+            id: c,
+            entry: this.candidateToCatalogEntry(c, repositories)
+          })),
+          ...lib.entries.map((e) => ({ id: this.entryIdentity(e), entry: e }))
+        ],
+        Object.keys(this.tryReadLock()?.assets ?? {}).map(parseCanonicalLockKey)
+      );
+    }
     this.assertSourceCommitsPublished(resolved, repositories);
     const stillMissing = missing.filter((m) => !lib.resolved.has(m));
     const lockedKeys = new Set(Object.keys(this.tryReadLock()?.assets ?? {}));
@@ -2494,6 +2651,10 @@ var AssetManager = class {
     const missingHints = await this.publisherChangeHints(stillMissing);
     const prevLock = this.tryReadLock();
     const kept = keptLockEntries(prevLock, stillMissing);
+    const storeNotChecked = this.storeNotCheckedRefs(
+      kept,
+      sources.map((s) => s.url)
+    );
     const fixes = await this.unresolvedFixes(stillMissing);
     for (const ref of /* @__PURE__ */ new Set([...kept.refs, ...fixes.keys()])) {
       const fix = fixes.get(ref);
@@ -2516,6 +2677,8 @@ var AssetManager = class {
     );
     const entries = [...await this.buildCatalogEntries(resolved, repositories), ...lib.entries];
     const copyDrift = await this.lockedCopyDrift();
+    const missingCopies = await this.incompleteDeploys();
+    const unrecordedAgents = this.unrecordedAgentFiles(prevLock);
     const deployed = [
       ...new Set(
         this.targetHarnesses().flatMap(
@@ -2523,9 +2686,10 @@ var AssetManager = class {
         )
       )
     ];
-    const restored = this.restoredCopies(copyDrift, deployed);
     await this.renderDriverMcpConfig();
     const agentRender = await this.renderAgentInstances();
+    const restored = this.restoredCopies(copyDrift, deployed, missingCopies);
+    const rewritten = this.rewrittenAgentFiles(unrecordedAgents);
     const lockWanted = resolved.length > 0 || lib.entries.length > 0 || existsSync(this.lockPath);
     let lockWritten = false;
     let relocked = [];
@@ -2538,16 +2702,20 @@ var AssetManager = class {
     }
     this.recordInstallHistory(deployed, removed);
     const { npmInstalled, npmFailed } = await this.installRuntimeAssetDeps();
-    await this.adviseMissing(stillMissing, missingHints);
+    const reportedMissing = stillMissing.filter((m) => !storeNotChecked.some((n) => n.ref === m));
+    for (const n of storeNotChecked) delete missingHints[n.ref];
+    await this.adviseMissing(reportedMissing, missingHints);
     return {
       deployed,
       removed,
-      missing: stillMissing,
+      missing: reportedMissing,
+      ...storeNotChecked.length > 0 ? { storeNotChecked } : {},
       ...Object.keys(missingHints).length > 0 ? { missingHints } : {},
       ...relocked.length > 0 ? { relocked } : {},
       ...moved.length > 0 ? { moved } : {},
       ...replaced.length > 0 ? { replaced } : {},
       ...restored.length > 0 ? { restored } : {},
+      ...rewritten.length > 0 ? { rewritten } : {},
       lockWritten,
       npmInstalled,
       npmFailed,
@@ -2555,6 +2723,41 @@ var AssetManager = class {
       ...agentRender
     };
   }
+  /**
+   * The kept refs whose locked copy came from a store that `install` did not (or could not)
+   * ask, and whose deployed copy is still there: nothing says the copy is wrong, so it stays
+   * and the run does not fail on it. A ref whose store answered "no such asset", one with no
+   * deployed copy, and one a source or library used to supply stay missing.
+   *
+   * @param declaredSourceUrls - The `sources:` URLs of `skaile.yaml`; a lock entry from one of
+   *   them is that source's, not the store's.
+   */
+  storeNotCheckedRefs(kept, declaredSourceUrls) {
+    const skipped = this.catalogUrlOverride === "";
+    if (!skipped && this.storeFailures.size === 0) return [];
+    const declared = new Set(declaredSourceUrls.map(normalizeRepoUrl));
+    const out = [];
+    for (const ref of kept.refs) {
+      const keys = kept.keysByRef.get(ref) ?? [];
+      const fromStore = keys.some((key) => {
+        const entry = kept.assets[key];
+        return entry !== void 0 && !entry.library && entry.source !== void 0 && !declared.has(normalizeRepoUrl(entry.source.url));
+      });
+      if (!fromStore || !this.keptCopyDeployed(kept, ref)) continue;
+      if (skipped && this.storeFailures.size === 0) {
+        out.push({ ref, reason: "skipped", detail: "--no-catalog: the store was not asked" });
+        continue;
+      }
+      const urls = [...this.storeFailures.keys()];
+      const airGapped = urls.every((url) => this.airGappedStores.has(url));
+      out.push({
+        ref,
+        reason: airGapped ? "air-gapped" : "unreachable",
+        detail: [...this.storeFailures.values()].join("; ")
+      });
+    }
+    return out;
+  }
   /**
    * Extend `kept` (see {@link keptLockEntries}) with every previous lock entry a kept asset
    * requires, transitively, that the new lock (`freshKeys`) does not already carry. The lock
@@ -2593,17 +2796,35 @@ var AssetManager = class {
     const { kind, name, publisher } = id;
     const component = kind ? this.installTarget(kind) : void 0;
     if (!kind || !name || !component) return [];
+    const locked = this.lockedRequirementsOf(id);
+    const withLocked = (scanned) => [.../* @__PURE__ */ new Set([...scanned, ...locked])];
     const keptAgent = kind === "agent" && !this.global ? join(agentSourceCacheDir(this.projectDir), name) : null;
     const dir = keptAgent && existsSync(keptAgent) ? keptAgent : deployedDir(component, name, this.driverTarget, this.global, this.projectDir);
-    if (!existsSync(dir)) return [];
+    if (!existsSync(dir)) return withLocked([]);
     try {
       const scanned = await scanDirectory(dir, publisher ?? "", { knownKinds: this.knownKinds });
       const own = scanned.find((e) => e.kind === kind && e.name === name);
-      return own ? libraryEntryDepRefs(own) : [];
+      return withLocked(own ? libraryEntryDepRefs(own) : []);
     } catch {
-      return [];
+      return withLocked([]);
     }
   }
+  /**
+   * The `requires:` the lock recorded for the store-resolved asset `id` (see
+   * {@link LockEntry.requires}): what its deployed copy cannot say, a store agent's skills.
+   * Empty for an asset the lock does not hold or records none for.
+   */
+  lockedRequirementsOf(id) {
+    const out = [];
+    for (const [key, entry] of Object.entries(this.tryReadLock()?.assets ?? {})) {
+      if (!entry.requires?.length) continue;
+      const k = parseCanonicalLockKey(key);
+      if (k.kind !== id.kind || k.name !== id.name) continue;
+      if (id.publisher && k.publisher && k.publisher !== id.publisher) continue;
+      out.push(...entry.requires);
+    }
+    return out;
+  }
   /**
    * Ensure all source clones are present/up to date. Returns an early
    * {@link InstallResult} describing the failed source on the first error, or
@@ -2749,6 +2970,8 @@ var AssetManager = class {
   noteStoreFailure(storeUrl, err) {
     const text = err instanceof OfflineError ? `${storeUrl}: air-gapped (catalog.cache_ttl: 0), the store was not asked` : describeCatalogError(err, storeUrl);
     this.storeFailures.set(storeUrl, text);
+    if (err instanceof OfflineError) this.airGappedStores.add(storeUrl);
+    else this.airGappedStores.delete(storeUrl);
     return text;
   }
   /** Build a store fetcher from the configured stores, or undefined when none. */
@@ -2943,6 +3166,8 @@ var AssetManager = class {
     }
     const library = await this.restoreLibraryLockEntries(lock);
     const copyDrift = await this.lockedCopyDrift();
+    const missingCopies = await this.incompleteDeploys();
+    const unrecordedAgents = this.unrecordedAgentFiles(lock);
     const deployed = [
       ...new Set(
         this.targetHarnesses().flatMap(
@@ -2955,9 +3180,10 @@ var AssetManager = class {
         )
       )
     ];
-    const restored = this.restoredCopies(copyDrift, deployed);
     await this.renderDriverMcpConfig();
     const agentRender = await this.renderAgentInstances();
+    const restored = this.restoredCopies(copyDrift, deployed, missingCopies);
+    const rewritten = this.rewrittenAgentFiles(unrecordedAgents);
     const alreadyMissing = new Set(
       library.missing.map((m) => {
         const p = parseRefTolerant(m.split(" ")[0] ?? m);
@@ -2975,9 +3201,32 @@ var AssetManager = class {
       missing: [...library.missing, ...gaps],
       lockWritten: false,
       ...restored.length > 0 ? { restored } : {},
+      ...rewritten.length > 0 ? { rewritten } : {},
       ...agentRender
     };
   }
+  /**
+   * The versions of `parsed`'s name that a source, a library or a store holds, newest first,
+   * for the `Asset not found` of a pinned ref. Empty for an unpinned ref (nothing was ruled
+   * out by a version) and when the name is unknown everywhere. A store that cannot be asked
+   * adds nothing here: its failure is reported by the caller.
+   */
+  async availableVersions(parsed, projectStores) {
+    if (!parsed.pin) return [];
+    const unpinned = assetRefToStr({ ...parsed, pin: void 0 });
+    const found = /* @__PURE__ */ new Set();
+    try {
+      const own = await this.info(unpinned);
+      if (own?.version) found.add(own.version);
+    } catch {
+    }
+    const stores = [...projectStores, ...await this.globalStoreFallback(projectStores)];
+    const fetcher = this.storeFetcherFor(stores);
+    for (const store of stores) {
+      for (const v of await fetcher?.listVersions?.(store.url, unpinned) ?? []) found.add(v);
+    }
+    return [...found].sort((a, b) => gt(coerceVersion(a), coerceVersion(b)) ? -1 : 1);
+  }
   /**
    * Parse the ref `add` was given. A ref the grammar rejects fails with the parser's message
    * minus its manifest-migration advice (it points at a skill that is not for `add`), and:
@@ -3100,8 +3349,9 @@ var AssetManager = class {
           `Store unreachable \u2014 ${ref} was not looked up: ${unreachable.join("; ")}. Check the URL with \`skaile catalog test\`; a library or source can still hold the asset.`
         );
       }
+      const available = await this.availableVersions(parsed, stores);
       throw new Error(
-        `Asset not found: ${ref}${(await this.publisherChangeHints([ref]))[ref] ?? ""}${missing.length ? ` (missing: ${missing.join(", ")})` : ""}`
+        `Asset not found: ${ref}${(await this.publisherChangeHints([ref]))[ref] ?? ""}${missing.length ? ` (missing: ${missing.join(", ")})` : ""}${available.length ? `; ${parsed.name} has version(s): ${available.join(", ")}` : ""}`
       );
     }
     if (parsed.kind === "preset" && missing.length > 0) {
@@ -3189,7 +3439,10 @@ var AssetManager = class {
       if (opts?.onLibraryMoved) {
         for (const m of libraryMoves(prevLock, libraryLock)) opts.onLibraryMoved(m);
       }
-      writeLock(this.lockPath, mergeLockFile(prevLock, this.withRenderedAgents(fresh)));
+      writeLock(
+        this.lockPath,
+        this.withInstanceRenderings(mergeLockFile(prevLock, this.withRenderedAgents(fresh)))
+      );
     }
     for (const d of deployed) {
       appendHistory(this.projectDir, {
@@ -3456,9 +3709,9 @@ var AssetManager = class {
    * @throws When `ref` is malformed, or a short ref matches several assets (the
    *   message lists them).
    */
-  remove(ref) {
+  remove(ref, opts) {
     const target = this.resolveRemoveTarget(ref);
-    return target ? this.removeResolved(target) : false;
+    return target ? this.removeResolved(target, { force: opts?.force }) : false;
   }
   /**
    * {@link remove} `ref`, then drop the dependencies that removal left orphaned:
@@ -3489,7 +3742,14 @@ var AssetManager = class {
     }
     let requiredRefs;
     if (entry) {
-      requiredRefs = libraryEntryDepRefs(entry);
+      requiredRefs = [
+        ...libraryEntryDepRefs(entry),
+        ...this.lockedRequirementsOf({
+          kind: target.kind,
+          name: target.name,
+          publisher: target.publisher
+        })
+      ];
     } else {
       const lockedAs = Object.keys(this.tryReadLock()?.assets ?? {}).map(parseCanonicalLockKey).find(
         (id) => id.kind === target.kind && id.name === target.name && (!target.publisher || id.publisher === target.publisher)
@@ -3500,9 +3760,11 @@ var AssetManager = class {
         publisher: target.publisher ?? lockedAs?.publisher
       });
     }
-    const changed = this.removeResolved(target);
-    if (!changed || requiredRefs.length === 0) return { changed, pruned: [] };
-    return { changed, pruned: await this.pruneOrphans(requiredRefs) };
+    const kept = [];
+    const changed = this.removeResolved(target, { force: opts?.force, kept });
+    const keptNote = kept.length > 0 ? { kept } : {};
+    if (!changed || requiredRefs.length === 0) return { changed, pruned: [], ...keptNote };
+    return { changed, pruned: await this.pruneOrphans(requiredRefs), ...keptNote };
   }
   /**
    * Resolve the identity {@link remove} acts on. A publisher-qualified ref is taken
@@ -3597,14 +3859,34 @@ var AssetManager = class {
     }
     return found;
   }
-  /** Undeploy `parsed` from every target harness and drop its declaration and lock entry. */
-  removeResolved(parsed) {
+  /** Whether a lock entry holds `kind:name` (any publisher): the deployed folder is then the project's copy of it. */
+  lockHolds(kind, name) {
+    return Object.keys(this.tryReadLock()?.assets ?? {}).map(parseCanonicalLockKey).some((id) => id.kind === kind && id.name === name);
+  }
+  /** The folders or files of `kind:name` on disk in `target`, shown relative to the project. */
+  heldDeployPaths(kind, name, target) {
+    const component = this.installTarget(kind);
+    if (!component) return [];
+    return deployedPaths(component, name, target, this.global, this.projectDir).filter((p) => existsSync(p)).map((p) => this.global ? p : relative(this.projectDir, p));
+  }
+  /**
+   * Undeploy `parsed` from every target harness and drop its declaration and lock entry.
+   *
+   * A folder no lock entry holds is the user's own work (a hand-made skill of the same name):
+   * it is kept and named in `opts.kept` unless `opts.force`.
+   */
+  removeResolved(parsed, opts = {}) {
     const wantPub = parsed.publisher?.replace(/^@/, "");
     const tracked = this.trackedPublishers(parsed.kind, parsed.name);
     const someoneElses = wantPub !== void 0 && tracked.size > 0 && !tracked.has(wantPub) && !tracked.has(void 0);
+    const owned = opts.force === true || this.lockHolds(parsed.kind, parsed.name);
     let undeployed = false;
     if (!someoneElses) {
       for (const t of this.targetHarnesses()) {
+        if (!owned) {
+          opts.kept?.push(...this.heldDeployPaths(parsed.kind, parsed.name, t));
+          continue;
+        }
         if (removeAsset(parsed.kind, parsed.name, this.deployOptsFor(t))) undeployed = true;
       }
     }
@@ -4066,8 +4348,10 @@ var AssetManager = class {
     const repoStatuses = this.buildRepoStatuses(repositories);
     const lockByKindName = indexLockByKindName(lock);
     const entries = [];
+    const instanceFiles = this.global ? /* @__PURE__ */ new Set() : instanceRenderedAgentNames(this.projectDir, this.driverTarget);
     for (const d of deployed) {
       const lockEntry = lockByKindName.get(`${d.kind}:${d.name}`);
+      if (!lockEntry && d.kind === "agent" && instanceFiles.has(d.name)) continue;
       const publisher = lockEntry?.publisher || "unknown";
       const version = lockEntry?.version ?? "";
       const slug = lockEntry && !lockEntry.library ? sourceCacheKey(lockEntry.url) : "";
@@ -4122,7 +4406,7 @@ var AssetManager = class {
       const out = [];
       try {
         const entry = await this.info(ref);
-        const deps = entry ? libraryEntryDepRefs(entry) : lock.assets[node] ? await this.deployedRequirementsOf(parseCanonicalLockKey(node)) : [];
+        const deps = entry ? [...libraryEntryDepRefs(entry), ...lock.assets[node]?.requires ?? []] : lock.assets[node] ? await this.deployedRequirementsOf(parseCanonicalLockKey(node)) : [];
         for (const dep of deps) {
           const key = findKey(dep);
           if (key && key !== node && !out.includes(key)) out.push(key);
@@ -4398,9 +4682,61 @@ var AssetManager = class {
           }
         }
       }
+      await this.addLibraryMoves(libraryAssets, result);
     }
     return this.addLockGapRows(result);
   }
+  /**
+   * List a locked library asset that `update` would move to another library (a default-library
+   * switch, a library that now holds a newer version) as `library → movesTo`, so `outdated`
+   * does not say "up to date" and `update` then re-locks it announced only after the fact.
+   * The resolution is the one `update` runs ({@link lockedPreference}); an asset already listed
+   * with a version row gets the target library on that row.
+   */
+  async addLibraryMoves(libraryAssets, rows) {
+    const refs = [];
+    const lockedIn = /* @__PURE__ */ new Map();
+    for (const [key, entry] of libraryAssets) {
+      const { publisher, kind, name } = parseCanonicalLockKey(key);
+      if (!publisher || !kind || !name || !entry.library) continue;
+      const ref = `${kind}:@${publisher}/${name}`;
+      refs.push(ref);
+      lockedIn.set(ref, { name: entry.library.name, key });
+    }
+    if (refs.length === 0) return;
+    let res;
+    try {
+      res = await this.resolveLibraryEntries(refs, {
+        quiet: true,
+        preferLocked: await this.lockedPreference()
+      });
+    } catch {
+      return;
+    }
+    for (const e of res.entries) {
+      const to = res.libraryOf.get(e);
+      const publisher = (e.publisher ?? "").replace(/^@/, "");
+      const ref = `${e.kind}:@${publisher}/${e.name}`;
+      const from = lockedIn.get(ref);
+      if (!to || !from || from.name === to) continue;
+      const row = rows.find(
+        (r) => r.kind === e.kind && r.name === e.name && r.publisher.replace(/^@/, "") === publisher
+      );
+      if (row) {
+        row.movesTo = to;
+        continue;
+      }
+      rows.push({
+        kind: e.kind,
+        name: e.name,
+        publisher,
+        currentVersion: parseCanonicalLockKey(from.key).version ?? "",
+        behind: 0,
+        library: from.name,
+        movesTo: to
+      });
+    }
+  }
   /**
    * Add one `problem` row per {@link AssetManager.projectState} gap whose asset is not
    * listed yet, so `outdated` lists the same assets `check`, `doctor` and `install --locked`
@@ -4706,7 +5042,7 @@ var AssetManager = class {
         }
         continue;
       }
-      const declaredRequires = full ? full.requires : (await this.deployedRequirementsOf({ ...entry, publisher })).map(parseDep);
+      const declaredRequires = full ? [...full.requires, ...(full.dependencies ?? []).filter(Boolean).map(parseDep)] : (await this.deployedRequirementsOf({ ...entry, publisher })).map(parseDep);
       const gaps = [];
       const requirements = dedupeRequirements(declaredRequires, publisher).map(
         (r) => r.publisher || !publisher ? r : { ...r, publisher }
@@ -4872,7 +5208,7 @@ var AssetManager = class {
     }
     gaps.push(...await this.declaredGaps(requirements, named));
     for (const d of await this.incompleteDeploys()) {
-      const reason = `is deployed without ${d.missing.join(", ")} \u2014 run \`skaile install\` to restore it`;
+      const reason = `is deployed without ${d.missing.join(", ")} \u2014 run \`skaile install --locked\` to restore it`;
       gaps.push({ type: "incomplete", ref: d.ref, reason, message: `${d.ref} ${reason}` });
     }
     const skipped = [];
@@ -4934,6 +5270,17 @@ var AssetManager = class {
       return k.kind === "agent" && k.name === parsedRef?.name && (!publisher || !k.publisher || k.publisher === publisher);
     });
     if (lockedAgent) {
+      const libraryFix = (await this.unresolvedFixes([ref])).get(ref);
+      if (libraryFix) {
+        const register = libraryFix.replace(
+          /, or drop the dependency with `skaile remove [^`]*`$/,
+          ""
+        );
+        return {
+          lead: "the agent is locked but its library cannot supply it here",
+          advice: `${register}, ${drop}`
+        };
+      }
       return {
         lead: "the agent is locked but not restored here",
         advice: `run \`skaile install --locked\` first, ${drop}`
@@ -5091,7 +5438,8 @@ var AssetManager = class {
         gaps.push({ type: "library", ref, reason: reason2, message: `${ref} ${reason2}` });
         continue;
       }
-      const reason = `is locked, but library "${lookup.name}" no longer holds it \u2014 restore it there, or drop the dependency with \`skaile remove ${ref}\``;
+      const renamedTo = await this.renamedFlowRef(lookup, publisher, kind, name);
+      const reason = renamedTo ? `is locked, but library "${lookup.name}" holds it as ${renamedTo} now (a flow is named by its \`id:\`) \u2014 run \`skaile remove ${ref}\`, then \`skaile add ${renamedTo}\`` : `is locked, but library "${lookup.name}" no longer holds it \u2014 restore it there, or drop the dependency with \`skaile remove ${ref}\``;
       gaps.push({ type: "library", ref, reason, message: `${ref} ${reason}`, manualFix: true });
     }
     return gaps;
@@ -5111,53 +5459,153 @@ var AssetManager = class {
       const rendered = this.renderedAgentFiles(name);
       if (rendered.length > 0) entry.rendered = rendered;
     }
+    return this.withInstanceRenderings(lock);
+  }
+  /**
+   * Make the `rendered:` list of every agent entry say exactly which files belong to it: the
+   * asset-named files of its own rendering (hashes kept as recorded) plus the files of the agent
+   * instances whose `ref` names it (`.claude/agents/default.md`, …) with their current sha256,
+   * so a hand edit of an instance file is drift like one of the asset-named file. A path that is
+   * neither is dropped: an instance that left `skaile.yaml`, or was bound to another agent, no
+   * longer lists its file under the old entry. A file that is another entry's own rendering
+   * stays with that entry; an instance whose `ref` names no locked agent (a path ref) has no
+   * entry to hold its files. Call it after `renderAgentInstances`, which rewrites every
+   * instance file, so the bytes hashed are the ones just written.
+   */
+  withInstanceRenderings(lock) {
+    if (this.global) return lock;
+    const agentKeys = Object.keys(lock.assets).filter((k) => {
+      const { kind, name } = parseCanonicalLockKey(k);
+      return kind && name && this.installTarget(kind) === "agent";
+    });
+    const ownFiles = /* @__PURE__ */ new Map();
+    for (const key of agentKeys) {
+      const { name } = parseCanonicalLockKey(key);
+      ownFiles.set(key, new Set(this.renderedAgentFiles(name).map((f) => f.path)));
+    }
+    const instanceFiles = /* @__PURE__ */ new Map();
+    for (const instance of renderedInstanceFiles(this.projectDir, this.driverTarget)) {
+      const want = parseRefTolerant(instance.ref);
+      if (!want || want.kind !== "agent") continue;
+      const wantPublisher = want.publisher?.replace(/^@/, "");
+      const key = agentKeys.find((k) => {
+        const p = parseCanonicalLockKey(k);
+        return p.name === want.name && (wantPublisher === void 0 || p.publisher === wantPublisher);
+      });
+      if (!key) continue;
+      const files = [];
+      for (const rel of instance.files) this.hashTree(join(this.projectDir, rel), files);
+      const held = instanceFiles.get(key) ?? /* @__PURE__ */ new Map();
+      for (const f of files) {
+        const ownedElsewhere = agentKeys.some((k) => k !== key && ownFiles.get(k)?.has(f.path));
+        if (!ownedElsewhere) held.set(f.path, f);
+      }
+      instanceFiles.set(key, held);
+    }
+    for (const key of agentKeys) {
+      const entry = lock.assets[key];
+      if (entry.library?.installed) continue;
+      const own = ownFiles.get(key) ?? /* @__PURE__ */ new Set();
+      const instance = instanceFiles.get(key) ?? /* @__PURE__ */ new Map();
+      const byPath = /* @__PURE__ */ new Map();
+      for (const f of entry.rendered ?? []) if (own.has(f.path)) byPath.set(f.path, f);
+      for (const [path2, f] of instance) byPath.set(path2, f);
+      if (byPath.size > 0) {
+        entry.rendered = [...byPath.values()].sort((x, y) => x.path.localeCompare(y.path));
+      } else {
+        delete entry.rendered;
+      }
+    }
     return lock;
   }
+  /** Append the regular files under `path` (a file or a directory) to `out`, project-relative with sha256. Symlinks are skipped. */
+  hashTree(path2, out) {
+    let stat;
+    try {
+      stat = lstatSync(path2);
+    } catch {
+      return;
+    }
+    if (stat.isSymbolicLink()) return;
+    if (stat.isDirectory()) {
+      for (const child of readdirSync(path2).sort()) this.hashTree(join(path2, child), out);
+    } else if (stat.isFile()) {
+      out.push({
+        path: relative(this.projectDir, path2).split(sep).join("/"),
+        sha256: computeHash(path2)
+      });
+    }
+  }
   /** The files of one agent's rendering for the active harness, project-relative, with sha256. */
   renderedAgentFiles(name) {
     const out = [];
-    const walk = (path2) => {
-      let stat;
-      try {
-        stat = lstatSync(path2);
-      } catch {
-        return;
-      }
-      if (stat.isSymbolicLink()) return;
-      if (stat.isDirectory()) {
-        for (const child of readdirSync(path2).sort()) walk(join(path2, child));
-      } else if (stat.isFile()) {
-        out.push({
-          path: relative(this.projectDir, path2).split(sep).join("/"),
-          sha256: computeHash(path2)
-        });
-      }
-    };
     for (const path2 of deployedPaths("agent", name, this.driverTarget, false, this.projectDir)) {
-      walk(path2);
+      this.hashTree(path2, out);
     }
-    walk(
+    this.hashTree(
       join(
         dirname(deployedBase("agent", this.driverTarget, false, this.projectDir)),
         CODEX_IDENTITY_DIR,
         `${name}.md`
-      )
+      ),
+      out
     );
     return out.sort((a, b) => a.path.localeCompare(b.path));
   }
+  /**
+   * The rendered native files of every locked agent whose lock entry records no `rendered:`
+   * (a lock an older CLI wrote), as path → sha256, taken before a deploy. `check` cannot tell
+   * such a file from a stale one, so {@link rewrittenAgentFiles} compares it afterwards.
+   * Project mode only.
+   */
+  unrecordedAgentFiles(lock) {
+    const out = /* @__PURE__ */ new Map();
+    if (this.global || !lock) return out;
+    for (const [key, entry] of Object.entries(lock.assets)) {
+      if (entry.rendered || entry.library?.installed) continue;
+      const { kind, name } = parseCanonicalLockKey(key);
+      if (!kind || !name || this.installTarget(kind) !== "agent") continue;
+      const files = this.renderedAgentFiles(name);
+      if (files.length > 0) out.set(key, new Map(files.map((f) => [f.path, f.sha256])));
+    }
+    return out;
+  }
+  /**
+   * The agent files a deploy changed that {@link unrecordedAgentFiles} saw before it: one row
+   * per locked agent, listing the project-relative paths whose bytes differ now. A render the
+   * CLI changed (the 5.12.0 abilities block) otherwise reaches the user as a silent rewrite.
+   */
+  rewrittenAgentFiles(before) {
+    const out = [];
+    for (const [key, files] of before) {
+      const { name } = parseCanonicalLockKey(key);
+      if (!name) continue;
+      const changed = this.renderedAgentFiles(name).filter((f) => files.has(f.path) && files.get(f.path) !== f.sha256).map((f) => f.path);
+      if (changed.length > 0) out.push({ ref: key, files: changed });
+    }
+    return out;
+  }
   /**
    * The {@link RestoredAsset} rows for the drifted copies (see {@link lockedCopyDrift}) a
    * deploy just wrote again: those whose ref is among the `deployed` canonical refs.
    */
-  restoredCopies(drifts, deployed) {
+  restoredCopies(drifts, deployed, incomplete = []) {
     const rewritten = new Set(deployed.map((d) => d.split("#")[0]));
     const out = [];
     for (const d of drifts) {
-      if (!rewritten.has(d.ref)) continue;
       if (d.rendered) {
-        out.push({ ref: d.key, restored: [...d.modified], removed: [] });
+        const restored = d.modified.filter((f) => {
+          if (rewritten.has(d.ref)) return true;
+          try {
+            return computeHash(join(this.projectDir, f)) === d.lockedSha?.get(f);
+          } catch {
+            return false;
+          }
+        });
+        if (restored.length > 0) out.push({ ref: d.key, restored, removed: [] });
         continue;
       }
+      if (!rewritten.has(d.ref)) continue;
       const { kind, name } = parseCanonicalLockKey(d.key);
       const component = kind ? this.installTarget(kind) : void 0;
       if (!kind || !name || !component) continue;
@@ -5171,6 +5619,22 @@ var AssetManager = class {
         removed: d.extra.map((f) => `${dir}/${f}`)
       });
     }
+    for (const inc of incomplete) {
+      const bare = inc.ref.split("#")[0];
+      const key = deployed.find((d) => d.split("#")[0] === bare);
+      if (!key) continue;
+      const { kind, name } = parseCanonicalLockKey(inc.ref);
+      const component = kind ? this.installTarget(kind) : void 0;
+      if (!kind || !name || !component) continue;
+      const dir = relative(
+        this.projectDir,
+        deployedDir(component, name, this.driverTarget, this.global, this.projectDir)
+      ).split(sep).join("/");
+      const files = inc.missing.map((f) => `${dir}/${f}`);
+      const row = out.find((r) => r.ref.split("#")[0] === bare);
+      if (row) row.restored.push(...files.filter((f) => !row.restored.includes(f)));
+      else out.push({ ref: key, restored: files, removed: [] });
+    }
     return out;
   }
   /**
@@ -5257,8 +5721,17 @@ var AssetManager = class {
           modified.push(f.path);
         }
       }
-      if (modified.length > 0)
-        out.push({ ref: refOf(key), key, modified, extra: [], library: false, rendered: true });
+      if (modified.length > 0) {
+        out.push({
+          ref: refOf(key),
+          key,
+          modified,
+          extra: [],
+          library: false,
+          rendered: true,
+          lockedSha: new Map(entry.rendered.map((f) => [f.path, f.sha256]))
+        });
+      }
     }
     return out;
   }
@@ -5275,7 +5748,10 @@ var AssetManager = class {
       const { publisher, kind, name } = parseCanonicalLockKey(key);
       const component = kind ? this.installTarget(kind) : void 0;
       if (!kind || !name || !component || named.has(`${kind}:${name}`)) continue;
-      if (isDeployed(component, name, this.driverTarget, this.global, this.projectDir)) continue;
+      if (isDeployed(component, name, this.driverTarget, this.global, this.projectDir)) {
+        const renderedGone = component === "agent" && !this.global && (entry.rendered ?? []).some((f) => !existsSync(join(this.projectDir, f.path)));
+        if (!renderedGone) continue;
+      }
       const ref = publisher ? `${kind}:@${publisher}/${name}` : `${kind}:${name}`;
       const reason = "is locked but its deployed copy is missing \u2014 run `skaile install --locked`";
       gaps.push({ type: "drift", ref, reason, message: `${ref} ${reason}` });
@@ -5749,5 +6225,5 @@ var AssetManager = class {
 };
 
 export { AssetManager, FACTORY_SOURCE_URL, MissingManifestError, installAgentInstances, normalizeRepoUrl, parseCanonicalLockKey, parseRefTolerant, renderMcpServerConfig, softDepName };
-//# sourceMappingURL=chunk-Y7WKXPWS.js.map
-//# sourceMappingURL=chunk-Y7WKXPWS.js.map
+//# sourceMappingURL=chunk-XX4C72CC.js.map
+//# sourceMappingURL=chunk-XX4C72CC.js.map