agentwheel 0.20.4 → 0.20.6

package/dist/{apply-MGOL643W.js → apply-OEKVIYBV.js}

@@ -5,8 +5,8 @@ import {
   commitManifestMetadataJournal,
   recoverPendingApply,
   uninstall
-} from "./chunk-XL4ZATLD.js";
-import "./chunk-JIATNPDH.js";
+} from "./chunk-4AM3LNUQ.js";
+import "./chunk-JXX6EDIP.js";
 import "./chunk-7VPI5J5Y.js";
 export {
   applyCombinedInstallPlan,

package/dist/{chunk-XL4ZATLD.js → chunk-4AM3LNUQ.js}

@@ -24,7 +24,7 @@ import {
   rollbackCompletedOperations,
   sourceLockPath,
   writeApplyJournal
-} from "./chunk-JIATNPDH.js";
+} from "./chunk-JXX6EDIP.js";
 import {
   pathExists,
   writeJsonAtomic
@@ -78,6 +78,7 @@ var graphLockRootSchema = z2.object({
   graphNodeId: z2.string().min(1),
   mode: z2.enum(["pinned", "tracking"]),
   selected: z2.array(z2.string().min(1)),
+  fullPackageSelected: z2.boolean().optional(),
   aliases: z2.record(z2.string(), z2.string().min(1)).optional(),
   overrides: z2.array(z2.string().min(1)).optional(),
   selectionImport: z2.object({

package/dist/{chunk-JIATNPDH.js → chunk-JXX6EDIP.js}

@@ -2625,8 +2625,8 @@ async function recoverMutationRuntime(operationId, options = {}) {
     }
     mutation = GovernedMutation.activateExisting(receipt, baseline, lock);
     const [{ recoverPendingApply }, { readLinkedLocalApplyJournal: readLinkedLocalApplyJournal2, removeApplyJournal: removeApplyJournal2, localPathExists: localPathExists2 }] = await Promise.all([
-      import("./apply-MGOL643W.js"),
-      import("./transaction-RJ34P3B6.js")
+      import("./apply-OEKVIYBV.js"),
+      import("./transaction-D7VRZZX5.js")
     ]);
     let missingReservation = false;
     for (const entry of pending) {

package/dist/index.js

@@ -33,7 +33,7 @@ import {
   uninstall,
   withManifestRevision,
   writeInstallManifest
-} from "./chunk-XL4ZATLD.js";
+} from "./chunk-4AM3LNUQ.js";
 import {
   CURRENT_WORKSPACE_SCHEMA_VERSION,
   GovernedMutation,
@@ -94,7 +94,7 @@ import {
   workspaceSelectionImportSchema,
   writeApplyJournal,
   writeWorkspaceConfig
-} from "./chunk-JIATNPDH.js";
+} from "./chunk-JXX6EDIP.js";
 import {
   inferSourceDriverName
 } from "./chunk-EMDIG24I.js";
@@ -3814,6 +3814,7 @@ async function matchingGitAuthProfile(url) {
   const config = await readGitAuthConfig();
   if (!config) return void 0;
   const repository = repositoryKey(url);
+  if (!repository) return void 0;
   return Object.values(config.profiles).find(
     (profile) => profile.repositories.some((pattern) => matchesRepository(pattern, repository))
   );
@@ -3847,8 +3848,13 @@ function parseGitAuthConfig(value, path) {
   return { profiles };
 }
 function repositoryKey(url) {
-  const parsed = new URL(url);
-  return `${parsed.host}/${parsed.pathname.replace(/^\//, "").replace(/\.git$/, "")}`.toLowerCase();
+  try {
+    const parsed = new URL(url);
+    if (!parsed.host) return void 0;
+    return `${parsed.host}/${parsed.pathname.replace(/^\//, "").replace(/\.git$/, "")}`.toLowerCase();
+  } catch {
+    return void 0;
+  }
 }
 function matchesRepository(pattern, repository) {
   const escaped = pattern.toLowerCase().replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
@@ -5962,16 +5968,27 @@ function normalizeLiteralProviderSpec(source, prefix) {
 }
 
 // src/resolve/graph.ts
+var TrackingRefreshRestart = class extends Error {
+  constructor(normalizedSource) {
+    super(`Restart graph resolution with a fresh tracking source: ${normalizedSource}`);
+    this.normalizedSource = normalizedSource;
+  }
+  normalizedSource;
+};
+var SnapshotConflictError = class extends Error {
+};
 var cacheLocks = /* @__PURE__ */ new Map();
 async function resolveDependencyGraph(roots, options) {
   if (roots.length === 0) throw new Error("At least one graph root is required.");
   const graphRoot = await mkdtemp2(join29(tmpdir3(), "agentwheel-graph-"));
   const fetchCache = /* @__PURE__ */ new Map();
   const nodesByKey = /* @__PURE__ */ new Map();
+  const nodesBySource = /* @__PURE__ */ new Map();
   const rootResults = [];
   const edgeMap = /* @__PURE__ */ new Map();
+  const trackingRefreshSources = /* @__PURE__ */ new Set();
   assertDependencyUpdateSelectors(options.previousLock, options.dependencyUpdateSelectors);
-  const queue = roots.map((root, index) => {
+  const rootRequirements = () => roots.map((root, index) => {
     const rootId = root.rootId ?? `root-${index + 1}`;
     return {
       source: root.source,
@@ -5994,15 +6011,33 @@ async function resolveDependencyGraph(roots, options) {
       suggestionAliases: sortedUnique2([...root.suggestionAliases ?? [], ...options.suggestionAliases ?? []])
     };
   });
+  const requiredQueue = rootRequirements();
+  const optionalQueue = [];
   let iterations = 0;
   const cap = Math.max(64, roots.length * 64);
-  while (queue.length > 0) {
+  while (requiredQueue.length > 0 || optionalQueue.length > 0) {
     if (++iterations > cap) {
       throw new Error(`Dependency graph did not reach a fixed point after ${cap} iterations.`);
     }
+    const queue = requiredQueue.length > 0 ? requiredQueue : optionalQueue;
     const batch = queue.splice(0, queue.length);
-    const next = await mapLimit(batch, options.concurrency ?? 4, async (requirement) => processRequirement(requirement, options, fetchCache, nodesByKey, rootResults, edgeMap));
-    queue.push(...next.flat());
+    try {
+      const next = (await mapLimit(batch, options.concurrency ?? 4, async (requirement) => processRequirement(requirement, options, fetchCache, nodesByKey, nodesBySource, rootResults, edgeMap, trackingRefreshSources))).flat();
+      for (const requirement of next) {
+        (requirement.optional ? optionalQueue : requiredQueue).push(requirement);
+      }
+    } catch (error) {
+      if (!(error instanceof TrackingRefreshRestart)) throw error;
+      trackingRefreshSources.add(error.normalizedSource);
+      nodesByKey.clear();
+      nodesBySource.clear();
+      rootResults.length = 0;
+      edgeMap.clear();
+      requiredQueue.length = 0;
+      optionalQueue.length = 0;
+      requiredQueue.push(...rootRequirements());
+      iterations = 0;
+    }
   }
   const rawNodes = [...nodesByKey.values()].sort((a, b) => a.node.id.localeCompare(b.node.id)).map((state) => materializeRawNode(state));
   const selectedByNodeId = new Map(rawNodes.map((raw) => [raw.node.id, raw.node.selected]));
@@ -6027,6 +6062,7 @@ function createGraphLock(graph, artifacts = [], targetFingerprint, includeEdges
     graphNodeId: root.graphNodeId,
     mode: root.mode,
     selected: root.selected,
+    fullPackageSelected: root.fullPackageSelected,
     aliases: root.aliases,
     overrides: root.overrides,
     selectionImport: root.selectionImport
@@ -6046,7 +6082,7 @@ function createGraphLock(graph, artifacts = [], targetFingerprint, includeEdges
     }
   };
 }
-async function processRequirement(requirement, options, fetchCache, nodesByKey, rootResults, edgeMap) {
+async function processRequirement(requirement, options, fetchCache, nodesByKey, nodesBySource, rootResults, edgeMap, trackingRefreshSources) {
   try {
     const lockLabel = options.offline ? "Offline" : options.frozenLock ? "Frozen lock" : "Locked install";
     let lockedByReference = lockedNodeForRequirementReference(requirement, options, lockLabel);
@@ -6077,7 +6113,18 @@ Run without ${lockLabel === "Offline" ? "--offline" : "--frozen-lock"} first.`
         requirement.updateClosure = true;
       }
     }
-    const frozen = lockedByReference ?? lockedNodeForRequirement(normalized.normalizedSource, requirement, options, lockLabel);
+    const hardLock = options.frozenLock === true || options.offline === true;
+    if (!hardLock && requirement.mode === "tracking" && !requirement.useLock && !trackingRefreshSources.has(normalized.normalizedSource)) {
+      throw new TrackingRefreshRestart(normalized.normalizedSource);
+    }
+    let frozen = lockedByReference ?? lockedNodeForRequirement(normalized.normalizedSource, requirement, options, lockLabel);
+    if (!hardLock && requirement.mode === "tracking" && frozen && !trackingRefreshSources.has(normalized.normalizedSource) && !lockedNodeCoversRequirementSelection(frozen.node, requirement, options)) {
+      throw new TrackingRefreshRestart(frozen.node.normalizedSource);
+    }
+    if (requirement.mode === "tracking" && trackingRefreshSources.has(normalized.normalizedSource)) {
+      lockedByReference = void 0;
+      frozen = void 0;
+    }
     let fetched;
     try {
       fetched = await fetchPackage(normalized, requirement.mode, options, fetchCache, frozen);
@@ -6102,7 +6149,13 @@ Run without ${lockLabel === "Offline" ? "--offline" : "--frozen-lock"} first.`
       requirement.chain
     );
     if (selectionImport) selectionImport = { ...selectionImport, effective: selected };
-    let state = nodesByKey.get(nodeKey);
+    const sourceState = nodesBySource.get(normalized.normalizedSource);
+    if (sourceState && (sourceState.node.resolvedCommit !== fetched.resolved.resolvedCommit || sourceState.node.sourceHash !== fetched.sourceHash)) {
+      throw new SnapshotConflictError(
+        `Conflicting locked and refreshed snapshots for ${normalized.normalizedSource}; the same package cannot be resolved as both pinned and tracking in one graph.`
+      );
+    }
+    let state = nodesByKey.get(nodeKey) ?? sourceState;
     if (!state) {
       const id = graphNodeId(fetched.name, fetched.version, normalized.normalizedSource, fetched.resolved.resolvedCommit, fetched.sourceHash);
       state = {
@@ -6137,7 +6190,9 @@ Run without ${lockLabel === "Offline" ? "--offline" : "--frozen-lock"} first.`
         updateClosure: false
       };
       nodesByKey.set(nodeKey, state);
+      nodesBySource.set(normalized.normalizedSource, state);
     }
+    if (requirement.mode === "tracking") state.node.mode = "tracking";
     state.depth = Math.min(state.depth, requirement.depth);
     state.fullPackageSelected = state.fullPackageSelected || requirement.select === void 0 && !requirement.selection;
     state.includeSuggestions = state.includeSuggestions || requirement.includeSuggestions === true;
@@ -6152,8 +6207,9 @@ Run without ${lockLabel === "Offline" ? "--offline" : "--frozen-lock"} first.`
         source: fetched.resolved.source,
         normalizedSource: normalized.normalizedSource,
         graphNodeId: state.node.id,
-        mode: state.node.mode,
+        mode: requirement.mode,
         selected: state.node.selected,
+        fullPackageSelected: requirement.select === void 0 && !requirement.selection,
         aliases: requirement.aliases,
         overrides: requirement.overrides,
         selectionImport
@@ -6177,6 +6233,7 @@ Run without ${lockLabel === "Offline" ? "--offline" : "--frozen-lock"} first.`
     }
     return await collectDependencyNeeds(state, fetched, options, requirement.chain);
   } catch (error) {
+    if (error instanceof TrackingRefreshRestart) throw error;
     if (requirement.optional) {
       const message2 = error instanceof Error ? error.message : String(error);
       options.warn?.(`optional dependency skipped: ${message2}`);
@@ -6199,17 +6256,19 @@ async function collectDependencyNeeds(state, fetched, options, chain) {
     warnNoDepsOnce(state, [...dependencyEntries.map(([alias]) => alias), ...suggestionEntries.map(([alias]) => alias)], options.warn);
   } else {
     for (const [alias, dependency] of dependencyEntries) {
-      if (state.processedPackageAliases.has(alias)) continue;
+      const processedKey = closureProcessingKey(alias, state.updateClosure);
+      if (state.processedPackageAliases.has(processedKey)) continue;
       if (!dependency.select?.length && !(state.fullPackageSelected && dependency.select === void 0)) continue;
-      state.processedPackageAliases.add(alias);
+      state.processedPackageAliases.add(processedKey);
       if (!dependencyTargetsRuntime(dependency.runtimes, options.runtime, state.node.id, alias, options.warn)) continue;
       requirements.push(dependencyRequirement(state, fetched, alias, dependency, dependency.select, chain, options));
     }
     for (const [alias, suggestion] of suggestionEntries) {
-      if (state.processedSuggestions.has(alias)) continue;
+      const processedKey = closureProcessingKey(alias, state.updateClosure);
+      if (state.processedSuggestions.has(processedKey)) continue;
       if (!shouldIncludeSuggestionAlias(alias, suggestionOptions, state.fullPackageSelected)) continue;
       if (!suggestion.select?.length && !(state.fullPackageSelected && suggestion.select === void 0) && !explicitSuggestionAlias(alias, suggestionOptions)) continue;
-      state.processedSuggestions.add(alias);
+      state.processedSuggestions.add(processedKey);
       if (!dependencyTargetsRuntime(suggestion.runtimes, options.runtime, state.node.id, alias, options.warn)) continue;
       requirements.push(suggestionRequirement(state, fetched, alias, suggestion, suggestion.select, chain, suggestionOptions));
     }
@@ -6217,10 +6276,10 @@ async function collectDependencyNeeds(state, fetched, options, chain) {
   const artifactsBySelector = new Map(fetched.artifacts.map((artifact) => [artifactSelectorKey(artifact), artifact]));
   const artifactsByRelativePath = new Map(fetched.artifacts.map((artifact) => [artifact.relativePath.replaceAll("\\", "/"), artifact]));
   while (true) {
-    const pending = [...state.selected].filter((selector) => !state.processedNeeds.has(selector)).sort((a, b) => a.localeCompare(b));
+    const pending = [...state.selected].filter((selector) => !state.processedNeeds.has(closureProcessingKey(selector, state.updateClosure))).sort((a, b) => a.localeCompare(b));
     if (pending.length === 0) break;
     for (const parentSelector of pending) {
-      state.processedNeeds.add(parentSelector);
+      state.processedNeeds.add(closureProcessingKey(parentSelector, state.updateClosure));
       const artifact = artifactsBySelector.get(parentSelector);
       if (!artifact) continue;
       if (!artifactTargetsRuntime(artifact.runtimes, options.runtime, state.node.id, parentSelector, options.warn)) continue;
@@ -6375,7 +6434,7 @@ function matchingDependencyUpdateEdges(lock, selector) {
   const nodes = new Map(lock.canonical.nodes.map((node) => [node.id, node]));
   return lock.canonical.edges.filter((edge) => {
     const node = nodes.get(edge.to);
-    if (!node || node.mode !== "tracking") return false;
+    if (!node || edge.mode !== "tracking") return false;
     return selector === edge.alias || selector === edge.source || selector === edge.normalizedSource || selector === node.id || selector === node.name || selector === node.source || selector === node.normalizedSource;
   });
 }
@@ -6622,6 +6681,28 @@ function lockedNodeForRequirement(normalizedSource, requirement, options, label)
     cacheIdentity: node.cacheIdentity
   };
 }
+function lockedNodeCoversRequirementSelection(node, requirement, options) {
+  if (requirement.mode !== "tracking") return true;
+  const lockedRoot = requirement.rootId ? options.previousLock?.canonical.roots.find((root) => root.rootId === requirement.rootId) : void 0;
+  if (requirement.depth === 0 && requirement.select === void 0 && !requirement.selection) {
+    return lockedRoot?.fullPackageSelected === true;
+  }
+  if (requirement.selection) {
+    const lockedSelection2 = lockedRoot?.selectionImport;
+    const requestedAdditions = normalizeArtifactSelectors(requirement.selection.add) ?? [];
+    const requestedExclusions = normalizeArtifactSelectors(requirement.selection.exclude) ?? [];
+    if (!lockedSelection2 || lockedSelection2.exportName !== requirement.selection.export) {
+      return false;
+    }
+    const requestedExclusionSet = new Set(requestedExclusions);
+    const requestedEffective = sortedUnique2([...lockedSelection2.inherited, ...requestedAdditions]).filter((selector) => !requestedExclusionSet.has(selector));
+    const lockedSelectors = new Set(node.selected);
+    return requestedEffective.every((selector) => lockedSelectors.has(selector));
+  }
+  const requested = normalizeArtifactSelectors(requirement.select) ?? [];
+  const lockedSelection = new Set(node.selected);
+  return requested.every((selector) => lockedSelection.has(selector));
+}
 function lockedNodeForRequirementReference(requirement, options, label) {
   const hard = options.frozenLock === true || options.offline === true;
   if (!hard && !requirement.useLock) return void 0;
@@ -6772,16 +6853,25 @@ function graphNodeId(name, version, normalizedSource, resolvedCommit, sourceHash
 function sortedUnique2(values) {
   return [...new Set(values)].sort((a, b) => a.localeCompare(b));
 }
+function closureProcessingKey(value, updateClosure) {
+  return `${updateClosure ? "update" : "locked"}\0${value}`;
+}
 async function mapLimit(items, limit, fn) {
   const out = new Array(items.length);
   let index = 0;
+  let failure;
   const workers = Array.from({ length: Math.max(1, Math.min(limit, items.length)) }, async () => {
-    while (index < items.length) {
+    while (index < items.length && failure === void 0) {
       const current = index++;
-      out[current] = await fn(items[current]);
+      try {
+        out[current] = await fn(items[current]);
+      } catch (error) {
+        failure ??= error;
+      }
     }
   });
   await Promise.all(workers);
+  if (failure !== void 0) throw failure;
   return out;
 }
 
@@ -14103,7 +14193,7 @@ function dependencyUpdateNodeIds(lock, selectors) {
   for (const selector of selectors) {
     for (const edge of lock.canonical.edges) {
       const node = nodes.get(edge.to);
-      if (!node || node.mode !== "tracking") continue;
+      if (!node || edge.mode !== "tracking") continue;
       if (selector === edge.alias || selector === edge.source || selector === edge.normalizedSource || selector === node.id || selector === node.name || selector === node.source || selector === node.normalizedSource) {
         selected.add(edge.to);
       }
@@ -14133,7 +14223,7 @@ function dependencyUpdatePackageNames(lock, selectors) {
     }
     for (const edge of lock.canonical.edges) {
       const node = nodes.get(edge.to);
-      if (!node || node.mode !== "tracking") continue;
+      if (!node || edge.mode !== "tracking") continue;
       if (selector === edge.alias || selector === edge.source || selector === edge.normalizedSource || selector === node.id || selector === node.name || selector === node.source || selector === node.normalizedSource) {
         names.add(node.name);
       }

package/dist/{transaction-RJ34P3B6.js → transaction-D7VRZZX5.js}

@@ -18,7 +18,7 @@ import {
   removeApplyJournal,
   rollbackCompletedOperations,
   writeApplyJournal
-} from "./chunk-JIATNPDH.js";
+} from "./chunk-JXX6EDIP.js";
 import "./chunk-7VPI5J5Y.js";
 export {
   abortApplyJournal,

package/openpack.json

@@ -1,7 +1,7 @@
 {
   "schemaVersion": 2,
   "name": "NestDevLab/agentwheel",
-  "version": "0.20.4",
+  "version": "0.20.6",
   "provides": [
     { "type": "skills", "path": "skills" }
   ]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentwheel",
-  "version": "0.20.4",
+  "version": "0.20.6",
   "description": "Weave skills, rules, and instructions across every AI agent.",
   "type": "module",
   "license": "MIT",

package/skills/agentwheel/SKILL.md

@@ -5,7 +5,7 @@ allowed-tools: [Bash]
 license: MIT
 metadata:
   author: NestDevLab
-  version: "0.20.4"
+  version: "0.20.6"
 ---
 
 # agentwheel

package/skills/agentwheel-discovery/SKILL.md

@@ -5,7 +5,7 @@ allowed-tools: [Bash]
 license: MIT
 metadata:
   author: NestDevLab
-  version: "0.20.4"
+  version: "0.20.6"
 ---
 
 # Agentwheel Discovery