agentwheel 0.14.13 → 0.16.0

package/dist/index.js

@@ -9,11 +9,11 @@ import {
 } from "./chunk-PKAPR55N.js";
 
 // src/cli/index.ts
-import { createHash as createHash11 } from "crypto";
+import { createHash as createHash12 } from "crypto";
 import { existsSync } from "fs";
-import { mkdir as mkdir22, rm as rm11, writeFile as writeFile21 } from "fs/promises";
-import { homedir as homedir9 } from "os";
-import { dirname as dirname31, join as join41, resolve as resolve20 } from "path";
+import { mkdir as mkdir23, rm as rm12, writeFile as writeFile22 } from "fs/promises";
+import { homedir as homedir10 } from "os";
+import { dirname as dirname32, join as join45, resolve as resolve22 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import { Command } from "commander";
 
@@ -810,13 +810,13 @@ async function spawnWithInput(command, args, input) {
   if (result.stderr) throw new Error(result.stderr);
 }
 function waitForProcess(child, label) {
-  return new Promise((resolve21, reject) => {
+  return new Promise((resolve23, reject) => {
     const stderr = [];
     child.stderr?.on("data", (chunk) => stderr.push(chunk));
     child.on("error", reject);
     child.on("close", (code) => {
       const message = Buffer.concat(stderr).toString("utf8");
-      if (code === 0) resolve21({ stderr: "" });
+      if (code === 0) resolve23({ stderr: "" });
       else reject(new Error(`${label} exited ${code}${message ? `: ${message}` : ""}`));
     });
   });
@@ -2592,6 +2592,7 @@ import { basename as basename8, join as join16, relative as relative3 } from "pa
 // src/staging/codex-subagents.ts
 import { mkdir as mkdir9, readFile as readFile11, writeFile as writeFile11 } from "fs/promises";
 import { basename as basename4, dirname as dirname12, join as join6 } from "path";
+import { parse as parseYaml } from "yaml";
 var requiredCodexAgentFields = ["name", "description", "developer_instructions"];
 async function renderCodexSubagents(artifacts, stageRoot, adapter) {
   if (adapter?.name !== "codex") return artifacts;
@@ -2664,24 +2665,36 @@ function markdownToCodexAgentToml(agentName, markdown) {
   const parsed = splitFrontmatter(markdown);
   const description = parsed.description ?? firstMeaningfulMarkdownLine(parsed.body) ?? `Custom Codex subagent ${agentName}.`;
   const developerInstructions = parsed.body.trim().length > 0 ? parsed.body.trimEnd() : description;
-  return [
+  const lines = [
     `name = ${tomlString(agentName)}`,
-    `description = ${tomlString(description)}`,
-    `developer_instructions = ${tomlMultilineString(developerInstructions)}`,
-    ""
-  ].join("\n");
+    `description = ${tomlString(description)}`
+  ];
+  if (parsed.model) lines.push(`model = ${tomlString(parsed.model)}`);
+  if (parsed.modelReasoningEffort) lines.push(`model_reasoning_effort = ${tomlString(parsed.modelReasoningEffort)}`);
+  lines.push(`developer_instructions = ${tomlMultilineString(developerInstructions)}`, "");
+  return lines.join("\n");
 }
 function splitFrontmatter(markdown) {
   const match = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/.exec(markdown);
   if (!match) return { body: markdown };
   const frontmatter = match[1] ?? "";
   const body = markdown.slice(match[0].length);
-  const description = frontmatter.split(/\r?\n/).map((line) => /^description:\s*(?:"([^"]*)"|'([^']*)'|(.+))\s*$/.exec(line.trim())).find((item) => item !== null);
+  const metadata = parseYaml(frontmatter);
   return {
     body,
-    description: description ? (description[1] ?? description[2] ?? description[3] ?? "").trim() : void 0
+    description: optionalFrontmatterString(metadata, "description"),
+    model: optionalFrontmatterString(metadata, "model"),
+    modelReasoningEffort: optionalFrontmatterString(metadata, "model_reasoning_effort")
   };
 }
+function optionalFrontmatterString(metadata, key) {
+  const value = metadata?.[key];
+  if (value === void 0 || value === null || value === "") return void 0;
+  if (typeof value !== "string") {
+    throw new Error(`Codex subagent frontmatter field '${key}' must be a string.`);
+  }
+  return value.trim();
+}
 function firstMeaningfulMarkdownLine(markdown) {
   for (const rawLine of markdown.split(/\r?\n/)) {
     const line = rawLine.trim();
@@ -5250,14 +5263,14 @@ async function writeMermaidAsset(response) {
     "content-type": "application/javascript; charset=utf-8",
     "cache-control": "public, max-age=3600"
   });
-  await new Promise((resolve21) => {
+  await new Promise((resolve23) => {
     const stream = createReadStream(assetPath);
     stream.on("error", () => {
       if (!response.headersSent) writeText(response, 404, "Mermaid asset unavailable.\n");
       else response.destroy();
-      resolve21();
+      resolve23();
     });
-    stream.on("end", resolve21);
+    stream.on("end", resolve23);
     stream.pipe(response);
   });
 }
@@ -5284,14 +5297,14 @@ function escapeHtml2(value) {
   return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
 }
 function listen(server, port, bind) {
-  return new Promise((resolve21, reject) => {
+  return new Promise((resolve23, reject) => {
     const onError = (error) => {
       server.off("listening", onListening);
       reject(error);
     };
     const onListening = () => {
       server.off("error", onError);
-      resolve21();
+      resolve23();
     };
     server.once("error", onError);
     server.once("listening", onListening);
@@ -5299,7 +5312,7 @@ function listen(server, port, bind) {
   });
 }
 function waitForShutdown(server, beforeClose) {
-  return new Promise((resolve21) => {
+  return new Promise((resolve23) => {
     let closing = false;
     const shutdown = () => {
       if (closing) return;
@@ -5307,7 +5320,7 @@ function waitForShutdown(server, beforeClose) {
       process.off("SIGINT", shutdown);
       process.off("SIGTERM", shutdown);
       beforeClose();
-      server.close(() => resolve21());
+      server.close(() => resolve23());
     };
     process.once("SIGINT", shutdown);
     process.once("SIGTERM", shutdown);
@@ -5317,7 +5330,7 @@ function waitForShutdown(server, beforeClose) {
       process.off("SIGINT", shutdown);
       process.off("SIGTERM", shutdown);
       beforeClose();
-      resolve21();
+      resolve23();
     });
   });
 }
@@ -5837,7 +5850,7 @@ async function fetchClawHubPackage(fetchImpl, packageName) {
   throw new Error(`ClawHub lookup failed for ${packageName}`);
 }
 async function delay(ms) {
-  await new Promise((resolve21) => setTimeout(resolve21, ms));
+  await new Promise((resolve23) => setTimeout(resolve23, ms));
 }
 function parseClawHubSource(source) {
   if (!source.startsWith(sourcePrefix)) {
@@ -5931,9 +5944,9 @@ var GitSourceDriver = class {
           throw new Error(`Frozen lock requires cached git checkout at ${resolved.resolvedPath}`);
         }
         await rm6(resolved.resolvedPath, { recursive: true, force: true });
-        await git(["clone", "--no-tags", parsed.url, resolved.resolvedPath]);
+        await git(["clone", parsed.url, resolved.resolvedPath]);
       } else if (!resolved.frozenLock) {
-        await git(["-C", resolved.resolvedPath, "fetch", "--prune", "origin"]);
+        await git(["-C", resolved.resolvedPath, "fetch", "--tags", "--prune", "origin"]);
       }
       const ref = resolved.requestedRef ?? parsed.ref ?? "HEAD";
       if (ref === "HEAD") {
@@ -6029,7 +6042,7 @@ async function withFilesystemLock(lockPath, timeoutMs, fn) {
       if (Date.now() - started > timeoutMs) {
         throw new Error(`Timed out waiting for git cache lock at ${lockPath}`);
       }
-      await new Promise((resolve21) => setTimeout(resolve21, 50));
+      await new Promise((resolve23) => setTimeout(resolve23, 50));
     }
   }
   try {
@@ -6538,8 +6551,8 @@ function getSourceDriver(name = "local") {
 }
 
 // src/staging/staging.ts
-import { chmod, cp as cp5, mkdir as mkdir17, mkdtemp as mkdtemp3, readdir as readdir5, stat as stat8 } from "fs/promises";
-import { basename as basename18, dirname as dirname22, join as join28, relative as relative7, resolve as resolve12, sep as sep2 } from "path";
+import { chmod, cp as cp5, mkdir as mkdir18, mkdtemp as mkdtemp3, readdir as readdir5, stat as stat8 } from "fs/promises";
+import { basename as basename19, dirname as dirname23, join as join29, relative as relative7, resolve as resolve12, sep as sep2 } from "path";
 import { tmpdir as tmpdir4 } from "os";
 
 // src/compose/markdown.ts
@@ -6953,6 +6966,57 @@ async function sortedDirEntries2(path) {
   return (await readdir4(path, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name));
 }
 
+// src/staging/claude-subagents.ts
+import { mkdir as mkdir17, readFile as readFile21, writeFile as writeFile19 } from "fs/promises";
+import { basename as basename18, dirname as dirname22, join as join28 } from "path";
+async function renderClaudeSubagents(artifacts, stageRoot, adapter) {
+  if (adapter?.name !== "claude") return artifacts;
+  const names = /* @__PURE__ */ new Set();
+  const rendered = [];
+  for (const artifact of artifacts) {
+    if (artifact.type !== "subagents") {
+      rendered.push(artifact);
+      continue;
+    }
+    const next = await renderClaudeSubagent(artifact, stageRoot);
+    if (names.has(next.name)) {
+      throw new Error(`Claude subagents produce duplicate agent name '${next.name}'.`);
+    }
+    names.add(next.name);
+    rendered.push(next);
+  }
+  return rendered;
+}
+async function renderClaudeSubagent(artifact, stageRoot) {
+  const sourcePath = artifact.stagedPath ?? artifact.sourcePath;
+  const agentName = claudeAgentName(artifact);
+  const markdownPath = artifact.kind === "dir" ? join28(sourcePath, "AGENTS.md") : sourcePath;
+  if (artifact.kind === "dir" && !await pathExists(markdownPath)) {
+    throw new Error(`Claude subagent directory ${artifact.relativePath} must contain AGENTS.md.`);
+  }
+  if (artifact.kind === "file" && !artifact.name.toLowerCase().endsWith(".md") && !sourcePath.toLowerCase().endsWith(".md")) {
+    throw new Error(`Claude subagent ${artifact.relativePath} must be a .md file or directory containing AGENTS.md.`);
+  }
+  const content = await readFile21(markdownPath, "utf8");
+  const renderedPath = join28(stageRoot, ".agentwheel-rendered", "claude-subagents", `${agentName}.md`);
+  await mkdir17(dirname22(renderedPath), { recursive: true });
+  await writeFile19(renderedPath, content.endsWith("\n") ? content : `${content}
+`, "utf8");
+  return {
+    ...artifact,
+    name: `${agentName}.md`,
+    sourcePath: renderedPath,
+    stagedPath: renderedPath,
+    relativePath: join28("subagents", `${agentName}.md`),
+    kind: "file",
+    hash: await hashPath(renderedPath)
+  };
+}
+function claudeAgentName(artifact) {
+  const raw = artifact.kind === "dir" ? artifact.name : basename18(artifact.name);
+  return raw.replace(/\.agent\.md$/i, "").replace(/\.md$/i, "");
+}
+
 // src/staging/staging.ts
 async function stageSource(driver, source, options = {}) {
   return renderStagedBundle(await stageSourceRaw(driver, source, options), options);
@@ -6966,15 +7030,15 @@ async function stageResolvedSourceRaw(driver, resolved) {
   return stageResolvedArtifactsRaw(resolved, artifacts);
 }
 async function stageResolvedArtifactsRaw(resolved, artifacts) {
-  const root = await mkdtemp3(join28(tmpdir4(), "agentwheel-stage-"));
+  const root = await mkdtemp3(join29(tmpdir4(), "agentwheel-stage-"));
   const stagedArtifacts = [];
   for (const artifact of artifacts) {
-    const stagedPath = join28(root, artifact.relativePath);
-    await mkdir17(dirname22(stagedPath), { recursive: true });
+    const stagedPath = join29(root, artifact.relativePath);
+    await mkdir18(dirname23(stagedPath), { recursive: true });
     await cp5(artifact.sourcePath, stagedPath, {
       recursive: artifact.kind === "dir",
       dereference: true,
-      filter: (path) => !isIgnoredGeneratedEntry(basename18(path))
+      filter: (path) => !isIgnoredGeneratedEntry(basename19(path))
     });
     await composeAssets(artifact, resolved.resolvedPath, stagedPath);
     stagedArtifacts.push({
@@ -7002,7 +7066,8 @@ async function renderStagedBundle(bundle, options = {}) {
   const selectedArtifacts = filterArtifactsBySelection(expandedArtifacts, options.select, options.skills);
   const runtimeSelectedSet = new Set(normalizeArtifactSelectors(options.select, options.skills) ?? []);
   const runtimeArtifacts = options.adapter ? filterArtifactsByRuntime(selectedArtifacts, options.adapter.name, runtimeSelectedSet) : selectedArtifacts;
-  const codexRenderedArtifacts = await renderCodexSubagents(runtimeArtifacts, root, options.adapter);
+  const claudeRenderedArtifacts = await renderClaudeSubagents(runtimeArtifacts, root, options.adapter);
+  const codexRenderedArtifacts = await renderCodexSubagents(claudeRenderedArtifacts, root, options.adapter);
   const openClawRenderedArtifacts = await renderOpenClawSubagents(codexRenderedArtifacts, root, options.adapter);
   const renderedArtifacts = await renderCopilotArtifacts(openClawRenderedArtifacts, root, options.adapter);
   const finalArtifacts = options.workspaceRoot && options.adapter ? await applyCustomizations(renderedArtifacts, {
@@ -7056,16 +7121,16 @@ async function composeAssets(artifact, packageRoot, stagedPath) {
   }
   for (const asset of artifact.assets) {
     const source = resolvePackagePath(packageRoot, asset.from);
-    const dest = join28(stagedPath, asset.into);
+    const dest = join29(stagedPath, asset.into);
     await copyAsset(asset, source, dest);
   }
 }
 async function copyAsset(asset, source, dest) {
   const sourceStats = await stat8(source);
   if (sourceStats.isFile()) {
-    if (matchesAny(basename18(source), asset.include)) {
-      await mkdir17(dest, { recursive: true });
-      await copyAssetFile(source, join28(dest, basename18(source)), asset);
+    if (matchesAny(basename19(source), asset.include)) {
+      await mkdir18(dest, { recursive: true });
+      await copyAssetFile(source, join29(dest, basename19(source)), asset);
     }
     return;
   }
@@ -7073,19 +7138,19 @@ async function copyAsset(asset, source, dest) {
     throw new Error(`Asset include source is not a file or directory: ${source}`);
   }
   if (!asset.include?.length) {
-    await mkdir17(dirname22(dest), { recursive: true });
+    await mkdir18(dirname23(dest), { recursive: true });
     await cp5(source, dest, { recursive: true, dereference: true });
     if (asset.mode === "copy") await normalizeCopiedModes(dest);
     return;
   }
   for (const file of await listFiles(source)) {
     const rel = relative7(source, file).replaceAll("\\", "/");
-    if (!matchesAny(rel, asset.include) && !matchesAny(basename18(file), asset.include)) continue;
-    await copyAssetFile(file, join28(dest, rel), asset);
+    if (!matchesAny(rel, asset.include) && !matchesAny(basename19(file), asset.include)) continue;
+    await copyAssetFile(file, join29(dest, rel), asset);
   }
 }
 async function copyAssetFile(source, dest, asset) {
-  await mkdir17(dirname22(dest), { recursive: true });
+  await mkdir18(dirname23(dest), { recursive: true });
   await cp5(source, dest, { dereference: true });
   if (asset.mode === "copy") await chmod(dest, 420);
 }
@@ -7101,7 +7166,7 @@ async function listFiles(root) {
   const out = [];
   async function walk2(dir) {
     for (const entry of (await readdir5(dir, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name))) {
-      const full = join28(dir, entry.name);
+      const full = join29(dir, entry.name);
       if (entry.isDirectory()) {
         await walk2(full);
       } else if (entry.isFile()) {
@@ -7120,7 +7185,7 @@ async function normalizeCopiedModes(path) {
   }
   if (!stats.isDirectory()) return;
   for (const entry of await readdir5(path, { withFileTypes: true })) {
-    await normalizeCopiedModes(join28(path, entry.name));
+    await normalizeCopiedModes(join29(path, entry.name));
   }
 }
 function matchesAny(path, patterns) {
@@ -7133,10 +7198,108 @@ function matchesGlob(path, pattern) {
 }
 
 // src/model/workspace.ts
-import { readFile as readFile21 } from "fs/promises";
+import { readFile as readFile22 } from "fs/promises";
 import { homedir as homedir4 } from "os";
-import { dirname as dirname23, join as join29, resolve as resolve13 } from "path";
+import { dirname as dirname24, join as join30, resolve as resolve13 } from "path";
 import { z as z6 } from "zod";
+
+// src/resolve/semver.ts
+var semverPattern = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/;
+function parseSemver(value) {
+  const match = semverPattern.exec(value.trim());
+  if (!match) return void 0;
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3]),
+    prerelease: match[4]
+  };
+}
+function satisfiesVersionRange(version, range) {
+  if (!range || range.trim() === "" || range.trim() === "*") return true;
+  const parsedVersion = parseSemver(version);
+  const trimmed = range.trim();
+  if (!parsedVersion) {
+    return trimmed === "*" || trimmed === version;
+  }
+  const comparators = parseRange(trimmed);
+  if (!comparators) return trimmed === version;
+  return comparators.every((comparator) => compareWith(parsedVersion, comparator));
+}
+function semverMajorOrVersion(version) {
+  const parsed = parseSemver(version);
+  return parsed ? String(parsed.major) : version;
+}
+function compareSemverStrings(a, b) {
+  const parsedA = parseSemver(a);
+  const parsedB = parseSemver(b);
+  if (!parsedA || !parsedB) return a.localeCompare(b);
+  return compareSemver(parsedA, parsedB);
+}
+function isSupportedVersionRange(range) {
+  const trimmed = range.trim();
+  return trimmed === "*" || parseRange(trimmed) !== void 0;
+}
+function parseRange(range) {
+  if (range === "*") return [];
+  if (range.startsWith("^")) {
+    const base = parseSemver(range.slice(1));
+    if (!base) return void 0;
+    return [
+      { op: ">=", version: base },
+      { op: "<", version: caretUpperBound(base) }
+    ];
+  }
+  if (range.startsWith("~")) {
+    const base = parseSemver(range.slice(1));
+    if (!base) return void 0;
+    return [
+      { op: ">=", version: base },
+      { op: "<", version: { major: base.major, minor: base.minor + 1, patch: 0 } }
+    ];
+  }
+  const parts = range.split(/\s+/).filter(Boolean);
+  const comparators = [];
+  for (const part of parts) {
+    const match = /^(>=|<=|>|<|=)?(.+)$/.exec(part);
+    if (!match) return void 0;
+    const version = parseSemver(match[2] ?? "");
+    if (!version) return void 0;
+    comparators.push({ op: match[1] ?? "=", version });
+  }
+  return comparators;
+}
+function caretUpperBound(version) {
+  if (version.major > 0) return { major: version.major + 1, minor: 0, patch: 0 };
+  if (version.minor > 0) return { major: 0, minor: version.minor + 1, patch: 0 };
+  return { major: 0, minor: 0, patch: version.patch + 1 };
+}
+function compareWith(version, comparator) {
+  const order = compareSemver(version, comparator.version);
+  switch (comparator.op) {
+    case "=":
+      return order === 0;
+    case ">":
+      return order > 0;
+    case ">=":
+      return order >= 0;
+    case "<":
+      return order < 0;
+    case "<=":
+      return order <= 0;
+  }
+}
+function compareSemver(a, b) {
+  for (const key of ["major", "minor", "patch"]) {
+    if (a[key] !== b[key]) return a[key] > b[key] ? 1 : -1;
+  }
+  if (a.prerelease === b.prerelease) return 0;
+  if (!a.prerelease) return 1;
+  if (!b.prerelease) return -1;
+  return a.prerelease.localeCompare(b.prerelease);
+}
+
+// src/model/workspace.ts
 var artifactSelectorListSchema = z6.array(z6.string().min(1));
 var workspaceSelectionImportSchema = z6.object({
   export: z6.string().min(1),
@@ -7177,6 +7340,9 @@ var workspacePackageBaseSchema = z6.object({
   adapterCodeHash: z6.string().min(16).optional(),
   installationType: installationTypeSchema.optional(),
   mode: z6.enum(["pinned", "tracking"]).default("pinned"),
+  version: z6.string().min(1).refine(isSupportedVersionRange, {
+    message: "Version policy must be an exact semver, ~range, ^range, comparator range, or *"
+  }).optional(),
   requestedRef: z6.string().min(1).optional(),
   select: z6.array(z6.string().min(1)).optional(),
   skills: z6.array(z6.string().min(1)).optional(),
@@ -7212,9 +7378,45 @@ var workspaceProfileRuntimeSchema = z6.object({
   reloadRuntimes: z6.boolean().optional(),
   reloadCommands: commandListSchema
 });
-var workspaceProfileSchema = z6.object({
-  runtimes: z6.array(workspaceProfileRuntimeSchema).min(1)
+var workspaceProfileMemberSchema = z6.object({
+  id: z6.string().min(1).regex(/^[a-z0-9][a-z0-9._-]*$/i),
+  workspace: z6.string().min(1),
+  profile: z6.string().min(1),
+  transport: z6.enum(["local", "ssh"]).default("local"),
+  host: z6.string().min(1).optional(),
+  user: z6.string().min(1).optional(),
+  port: z6.number().int().positive().optional(),
+  identityFile: z6.string().min(1).optional(),
+  refreshTtlSeconds: z6.number().int().positive().optional()
+}).strict().superRefine((member, ctx) => {
+  if (member.transport === "ssh" && !member.host) {
+    ctx.addIssue({ code: "custom", path: ["host"], message: "SSH profile members require host" });
+  }
+  if (member.transport === "ssh" && !member.workspace.startsWith("/")) {
+    ctx.addIssue({ code: "custom", path: ["workspace"], message: "SSH profile member workspaces must be absolute" });
+  }
+});
+var workspaceLeafProfileSchema = z6.object({
+  runtimes: z6.array(workspaceProfileRuntimeSchema).min(1),
+  members: z6.never().optional()
+}).strict();
+var workspaceCompositeProfileSchema = z6.object({
+  members: z6.array(workspaceProfileMemberSchema).min(1),
+  runtimes: z6.never().optional(),
+  refreshTtlSeconds: z6.number().int().positive().default(86400)
+}).strict().superRefine((profile, ctx) => {
+  const seen = /* @__PURE__ */ new Set();
+  for (const [index, member] of profile.members.entries()) {
+    if (seen.has(member.id)) {
+      ctx.addIssue({ code: "custom", path: ["members", index, "id"], message: "Composite profile member ids must be unique" });
+    }
+    seen.add(member.id);
+  }
 });
+var workspaceProfileSchema = z6.union([
+  workspaceLeafProfileSchema,
+  workspaceCompositeProfileSchema
+]);
 var workspaceRegistrySchema = z6.object({
   sources: z6.array(z6.string().min(1)).optional(),
   ttlSeconds: z6.number().int().positive().optional()
@@ -7269,12 +7471,12 @@ var workspaceConfigSchema = z6.discriminatedUnion("schemaVersion", [
   workspaceConfigV2Schema
 ]);
 function workspaceConfigPath(workspaceRoot) {
-  return join29(workspaceRoot, ".agentwheel", "config.json");
+  return join30(workspaceRoot, ".agentwheel", "config.json");
 }
 async function readWorkspaceConfig(workspaceRoot) {
   const path = workspaceConfigPath(workspaceRoot);
   if (!await pathExists(path)) return emptyWorkspaceConfig();
-  return workspaceConfigSchema.parse(JSON.parse(await readFile21(path, "utf8")));
+  return workspaceConfigSchema.parse(JSON.parse(await readFile22(path, "utf8")));
 }
 async function writeWorkspaceConfig(workspaceRoot, config) {
   await writeJsonAtomic(workspaceConfigPath(workspaceRoot), workspaceConfigSchema.parse(config));
@@ -7287,13 +7489,13 @@ function upsertPackage(config, entry) {
   return workspaceConfigSchema.parse({ ...parsed, packages });
 }
 function globalWorkspaceConfigPath(globalRoot = homedir4()) {
-  return join29(globalRoot, ".agentwheel", "config.json");
+  return join30(globalRoot, ".agentwheel", "config.json");
 }
 async function findWorkspaceRoot(start = process.cwd()) {
   let current = resolve13(start);
   while (true) {
     if (await pathExists(workspaceConfigPath(current))) return current;
-    const parent = dirname23(current);
+    const parent = dirname24(current);
     if (parent === current) return resolve13(start);
     current = parent;
   }
@@ -7330,9 +7532,12 @@ function resolveConfigPath(path, baseRoot) {
 function emptyWorkspaceConfig() {
   return { schemaVersion: 1, packages: [], registry: {}, trust: {}, profiles: {}, agents: {} };
 }
+function isCompositeWorkspaceProfile(profile) {
+  return "members" in profile && Array.isArray(profile.members);
+}
 async function readConfigPath(path) {
   if (!await pathExists(path)) return emptyWorkspaceConfig();
-  return workspaceConfigSchema.parse(JSON.parse(await readFile21(path, "utf8")));
+  return workspaceConfigSchema.parse(JSON.parse(await readFile22(path, "utf8")));
 }
 function mergeWorkspaceTrust(global, project) {
   return {
@@ -7347,18 +7552,18 @@ function sortedUnique2(values) {
 }
 
 // src/lifecycle/customization.ts
-import { appendFile, cp as cp6, mkdir as mkdir18, rm as rm9 } from "fs/promises";
-import { dirname as dirname25, join as join32 } from "path";
+import { appendFile, cp as cp6, mkdir as mkdir19, rm as rm9 } from "fs/promises";
+import { dirname as dirname26, join as join33 } from "path";
 
 // src/resolve/graph.ts
 import { createHash as createHash8 } from "crypto";
-import { mkdtemp as mkdtemp4, readdir as readdir6, readFile as readFile24, stat as stat10 } from "fs/promises";
+import { mkdtemp as mkdtemp4, readdir as readdir6, readFile as readFile25, stat as stat10 } from "fs/promises";
 import { tmpdir as tmpdir5 } from "os";
-import { basename as basename19, extname as extname4, join as join31 } from "path";
+import { basename as basename20, extname as extname4, join as join32 } from "path";
 
 // src/model/workspace-composition.ts
 import { createHash as createHash7 } from "crypto";
-import { readFile as readFile22 } from "fs/promises";
+import { readFile as readFile23 } from "fs/promises";
 import { z as z7 } from "zod";
 var selectionSourceConfigSchema = z7.object({
   schemaVersion: z7.literal(2),
@@ -7377,7 +7582,7 @@ async function resolveSelectionImport(sourceRoot, sourceDriver, selection) {
   }
   let raw;
   try {
-    raw = JSON.parse(await readFile22(path, "utf8"));
+    raw = JSON.parse(await readFile23(path, "utf8"));
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     throw new Error(`Selection import '${parsedSelection.export}' cannot parse ${path}: ${message}`);
@@ -7479,9 +7684,9 @@ import { homedir as homedir6 } from "os";
 import { resolve as resolve15 } from "path";
 
 // src/registry/client.ts
-import { readFile as readFile23, rm as rm8, stat as stat9 } from "fs/promises";
+import { readFile as readFile24, rm as rm8, stat as stat9 } from "fs/promises";
 import { homedir as homedir5 } from "os";
-import { dirname as dirname24, join as join30, resolve as resolve14 } from "path";
+import { dirname as dirname25, join as join31, resolve as resolve14 } from "path";
 import { fileURLToPath } from "url";
 
 // src/model/registry.ts
@@ -7554,13 +7759,6 @@ var RegistryClient = class {
     const index = await this.getIndex(options);
     return index.entries.find((entry) => entry.name === name);
   }
-  async search(query, options = {}) {
-    const q = query.toLowerCase();
-    const index = await this.getIndex(options);
-    return index.entries.filter(
-      (entry) => entry.name.toLowerCase().includes(q) || entry.description.toLowerCase().includes(q) || entry.tags.some((tag) => tag.toLowerCase().includes(q))
-    );
-  }
   async clearCache() {
     await rm8(this.cachePath, { force: true });
   }
@@ -7585,7 +7783,7 @@ var RegistryClient = class {
   }
   async readCache() {
     if (!await pathExists(this.cachePath)) return void 0;
-    return registryCacheSchema.parse(JSON.parse(await readFile23(this.cachePath, "utf8")));
+    return registryCacheSchema.parse(JSON.parse(await readFile24(this.cachePath, "utf8")));
   }
   isExpired(cache, ttlMs) {
     return this.now().getTime() - new Date(cache.fetchedAt).getTime() > ttlMs;
@@ -7604,10 +7802,10 @@ var RegistryClient = class {
     if (await pathExists(filePath)) {
       const fullPath = resolve14(filePath);
       const stats = await stat9(fullPath);
-      return readFile23(stats.isDirectory() ? join30(fullPath, "index.json") : fullPath, "utf8");
+      return readFile24(stats.isDirectory() ? join31(fullPath, "index.json") : fullPath, "utf8");
     }
-    const resolved = await this.git.fetch(await this.git.resolve(source, { cacheRoot: join30(dirname24(this.cachePath), "registry-repos") }));
-    return readFile23(join30(resolved.resolvedPath, "index.json"), "utf8");
+    const resolved = await this.git.fetch(await this.git.resolve(source, { cacheRoot: join31(dirname25(this.cachePath), "registry-repos") }));
+    return readFile24(join31(resolved.resolvedPath, "index.json"), "utf8");
   }
   warnCompatibility(entries) {
     for (const entry of entries) {
@@ -7645,7 +7843,7 @@ function mergeIndexes(indexes) {
   return [...merged.values()].sort((a, b) => a.name.localeCompare(b.name));
 }
 function defaultRegistryCachePath() {
-  return join30(homedir5(), ".agentwheel", "registry-cache.json");
+  return join31(homedir5(), ".agentwheel", "registry-cache.json");
 }
 function sameSources(a, b) {
   return a.length === b.length && a.every((source, index) => source === b[index]);
@@ -7805,97 +8003,11 @@ function normalizeLiteralProviderSpec(source, prefix) {
   return `${prefix}${spec}`;
 }
 
-// src/resolve/semver.ts
-var semverPattern = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/;
-function parseSemver(value) {
-  const match = semverPattern.exec(value.trim());
-  if (!match) return void 0;
-  return {
-    major: Number(match[1]),
-    minor: Number(match[2]),
-    patch: Number(match[3]),
-    prerelease: match[4]
-  };
-}
-function satisfiesVersionRange(version, range) {
-  if (!range || range.trim() === "" || range.trim() === "*") return true;
-  const parsedVersion = parseSemver(version);
-  const trimmed = range.trim();
-  if (!parsedVersion) {
-    return trimmed === "*" || trimmed === version;
-  }
-  const comparators = parseRange(trimmed);
-  if (!comparators) return trimmed === version;
-  return comparators.every((comparator) => compareWith(parsedVersion, comparator));
-}
-function semverMajorOrVersion(version) {
-  const parsed = parseSemver(version);
-  return parsed ? String(parsed.major) : version;
-}
-function parseRange(range) {
-  if (range === "*") return [];
-  if (range.startsWith("^")) {
-    const base = parseSemver(range.slice(1));
-    if (!base) return void 0;
-    return [
-      { op: ">=", version: base },
-      { op: "<", version: caretUpperBound(base) }
-    ];
-  }
-  if (range.startsWith("~")) {
-    const base = parseSemver(range.slice(1));
-    if (!base) return void 0;
-    return [
-      { op: ">=", version: base },
-      { op: "<", version: { major: base.major, minor: base.minor + 1, patch: 0 } }
-    ];
-  }
-  const parts = range.split(/\s+/).filter(Boolean);
-  const comparators = [];
-  for (const part of parts) {
-    const match = /^(>=|<=|>|<|=)?(.+)$/.exec(part);
-    if (!match) return void 0;
-    const version = parseSemver(match[2] ?? "");
-    if (!version) return void 0;
-    comparators.push({ op: match[1] ?? "=", version });
-  }
-  return comparators;
-}
-function caretUpperBound(version) {
-  if (version.major > 0) return { major: version.major + 1, minor: 0, patch: 0 };
-  if (version.minor > 0) return { major: 0, minor: version.minor + 1, patch: 0 };
-  return { major: 0, minor: 0, patch: version.patch + 1 };
-}
-function compareWith(version, comparator) {
-  const order = compareSemver(version, comparator.version);
-  switch (comparator.op) {
-    case "=":
-      return order === 0;
-    case ">":
-      return order > 0;
-    case ">=":
-      return order >= 0;
-    case "<":
-      return order < 0;
-    case "<=":
-      return order <= 0;
-  }
-}
-function compareSemver(a, b) {
-  for (const key of ["major", "minor", "patch"]) {
-    if (a[key] !== b[key]) return a[key] > b[key] ? 1 : -1;
-  }
-  if (a.prerelease === b.prerelease) return 0;
-  if (!a.prerelease) return 1;
-  if (!b.prerelease) return -1;
-  return a.prerelease.localeCompare(b.prerelease);
-}
-
 // src/resolve/graph.ts
 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 mkdtemp4(join31(tmpdir5(), "agentwheel-graph-"));
+  const graphRoot = await mkdtemp4(join32(tmpdir5(), "agentwheel-graph-"));
   const fetchCache = /* @__PURE__ */ new Map();
   const nodesByKey = /* @__PURE__ */ new Map();
   const rootResults = [];
@@ -7908,6 +8020,7 @@ async function resolveDependencyGraph(roots, options) {
       select: root.select,
       selection: root.selection,
       mode: root.mode ?? "pinned",
+      version: root.version,
       ref: root.ref,
       declaringPackageRoot: options.workspaceRoot,
       requiredBy: `workspace:${rootId}`,
@@ -8414,7 +8527,7 @@ async function collectIncludeNeeds(artifact, artifactsByRelativePath) {
     const file = stack.shift();
     if (scanned.has(file)) continue;
     scanned.add(file);
-    const content = await readFile24(file, "utf8");
+    const content = await readFile25(file, "utf8");
     for (const include of extractOpenPackIncludeSelectors(content)) {
       await collectIncludeSelector(include.raw, include.optional, artifactsByRelativePath, scanned, stack, needs);
     }
@@ -8457,7 +8570,7 @@ async function listMarkdownFiles2(root) {
   const out = [];
   async function walk2(dir) {
     for (const entry of (await readdir6(dir, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name))) {
-      const full = join31(dir, entry.name);
+      const full = join32(dir, entry.name);
       if (entry.isDirectory()) {
         await walk2(full);
       } else if (entry.isFile() && extname4(entry.name).toLowerCase() === ".md") {
@@ -8492,7 +8605,7 @@ async function fetchPackage(normalized, mode, options, fetchCache, refOverride)
   const promise = (async () => {
     const driver = getSourceDriver(normalized.driver);
     const resolved = await driver.resolve(normalized.source, {
-      cacheRoot: options.cacheRoot ?? join31(options.workspaceRoot, ".agentwheel", "cache"),
+      cacheRoot: options.cacheRoot ?? join32(options.workspaceRoot, ".agentwheel", "cache"),
       mode,
       ref: refOverride ?? normalized.requestedRef,
       frozenLock: hardLockedCheckout
@@ -8502,7 +8615,7 @@ async function fetchPackage(normalized, mode, options, fetchCache, refOverride)
     const exported = await driver.export(translated);
     const manifest = await readPackageManifest(exported.resolvedPath);
     const artifacts = await driver.list(exported);
-    const name = manifest?.name ?? exported.packageName ?? basename19(exported.resolvedPath);
+    const name = manifest?.name ?? exported.packageName ?? basename20(exported.resolvedPath);
     const version = manifest?.version ?? exported.packageVersion ?? "0.0.0";
     const sourceHash = exported.sourceHash ?? await hashPath(exported.resolvedPath);
     return {
@@ -8609,8 +8722,8 @@ function verifyIntegrity(integrity, sourceHash, label) {
 async function withCachePathLock(path, fn) {
   const previous = cacheLocks.get(path) ?? Promise.resolve();
   let release = () => void 0;
-  const current = previous.then(() => new Promise((resolve21) => {
-    release = resolve21;
+  const current = previous.then(() => new Promise((resolve23) => {
+    release = resolve23;
   }));
   cacheLocks.set(path, current);
   await previous;
@@ -8699,8 +8812,8 @@ async function mapLimit(items, limit, fn) {
 
 // src/lifecycle/customization.ts
 async function remember(workspaceRoot, runtime, text) {
-  const overlayPath = join32(workspaceRoot, ".agentwheel", "overlays", runtime, "instructions.local.md");
-  await mkdir18(dirname25(overlayPath), { recursive: true });
+  const overlayPath = join33(workspaceRoot, ".agentwheel", "overlays", runtime, "instructions.local.md");
+  await mkdir19(dirname26(overlayPath), { recursive: true });
   await appendFile(overlayPath, `${text.trim()}
 `, "utf8");
   return { overlayPath };
@@ -8723,8 +8836,8 @@ async function ejectArtifact(workspaceRoot, item) {
       throw new Error(`Artifact not found: ${item}`);
     }
     const ejectedIdentity = parsed.packageIdentity === parsed.packageName ? parsed.packageIdentity : candidate.nodeId === parsed.packageIdentity ? candidate.nodeId : `${candidate.packageName}@${candidate.packageVersion}`;
-    const ejectedPath = join32(workspaceRoot, ".agentwheel", "ejected", ...ejectedIdentity.split("/"), parsed.type, parsed.name);
-    await mkdir18(dirname25(ejectedPath), { recursive: true });
+    const ejectedPath = join33(workspaceRoot, ".agentwheel", "ejected", ...ejectedIdentity.split("/"), parsed.type, parsed.name);
+    await mkdir19(dirname26(ejectedPath), { recursive: true });
     await rm9(ejectedPath, { recursive: true, force: true });
     await cp6(artifact.stagedPath ?? artifact.sourcePath, ejectedPath, { recursive: artifact.kind === "dir", dereference: true });
     return {
@@ -8766,7 +8879,7 @@ async function stageEjectCandidate(workspaceRoot, pkg) {
   const adapter = pkg.adapterConfig ? await loadAdapterConfig(pkg.adapterConfig) : getAdapter(pkg.adapter);
   const bundle = await stageSource(driver, normalized.source, {
     adapter,
-    cacheRoot: join32(workspaceRoot, ".agentwheel", "cache"),
+    cacheRoot: join33(workspaceRoot, ".agentwheel", "cache"),
     mode: pkg.mode,
     ref: normalized.requestedRef ?? pkg.requestedRef
   });
@@ -8817,8 +8930,8 @@ import { rm as rm10 } from "fs/promises";
 
 // src/lifecycle/source-plan.ts
 import { createHash as createHash10 } from "crypto";
-import { mkdir as mkdir20 } from "fs/promises";
-import { dirname as dirname27, join as join35 } from "path";
+import { mkdir as mkdir21 } from "fs/promises";
+import { dirname as dirname28, join as join36 } from "path";
 
 // src/resolve/graph-diff.ts
 function diffGraphLocks(previous, next) {
@@ -8980,11 +9093,11 @@ function formatSelectionImport(root) {
 
 // src/resolve/render.ts
 import { createHash as createHash9 } from "crypto";
-import { readFile as readFile25, mkdtemp as mkdtemp5 } from "fs/promises";
+import { readFile as readFile26, mkdtemp as mkdtemp5 } from "fs/promises";
 import { tmpdir as tmpdir6 } from "os";
-import { join as join33 } from "path";
+import { join as join34 } from "path";
 async function renderGraphForTarget(graph, targetContext = {}) {
-  const root = await mkdtemp5(join33(tmpdir6(), "agentwheel-render-"));
+  const root = await mkdtemp5(join34(tmpdir6(), "agentwheel-render-"));
   const artifacts = [];
   const stagedNodes = /* @__PURE__ */ new Map();
   const includeEdges = /* @__PURE__ */ new Map();
@@ -9056,7 +9169,8 @@ async function renderGraphForTarget(graph, targetContext = {}) {
     const selectedArtifacts = filterArtifactsBySelection(expandedArtifacts, rawNode.node.selected);
     const runtimeSelectedSet = new Set(normalizeArtifactSelectors(rawNode.node.selected) ?? []);
     const runtimeArtifacts = targetContext.adapter ? filterArtifactsByRuntime2(selectedArtifacts, targetContext.adapter.name, runtimeSelectedSet) : selectedArtifacts;
-    const codexRenderedArtifacts = await renderCodexSubagents(runtimeArtifacts, staged.root, targetContext.adapter);
+    const claudeRenderedArtifacts = await renderClaudeSubagents(runtimeArtifacts, staged.root, targetContext.adapter);
+    const codexRenderedArtifacts = await renderCodexSubagents(claudeRenderedArtifacts, staged.root, targetContext.adapter);
     const openClawRenderedArtifacts = await renderOpenClawSubagents(codexRenderedArtifacts, staged.root, targetContext.adapter);
     const runtimeRenderedArtifacts = await renderCopilotArtifacts(openClawRenderedArtifacts, staged.root, targetContext.adapter);
     const renderedArtifacts = targetContext.workspaceRoot && targetContext.adapter ? await applyCustomizations(runtimeRenderedArtifacts, {
@@ -9105,7 +9219,7 @@ async function artifactContentMap(artifacts) {
   const out = /* @__PURE__ */ new Map();
   for (const artifact of artifacts) {
     if (artifact.kind !== "file") continue;
-    out.set(artifact.relativePath.replaceAll("\\", "/"), await readFile25(artifact.stagedPath ?? artifact.sourcePath, "utf8"));
+    out.set(artifact.relativePath.replaceAll("\\", "/"), await readFile26(artifact.stagedPath ?? artifact.sourcePath, "utf8"));
   }
   return out;
 }
@@ -9368,9 +9482,9 @@ function lockArtifactFor(artifact) {
 }
 
 // src/lifecycle/trust.ts
-import { mkdir as mkdir19, readFile as readFile26 } from "fs/promises";
+import { mkdir as mkdir20, readFile as readFile27 } from "fs/promises";
 import { homedir as homedir7 } from "os";
-import { dirname as dirname26, join as join34 } from "path";
+import { dirname as dirname27, join as join35 } from "path";
 import { z as z9 } from "zod";
 var trustStoreSchema = z9.object({
   version: z9.literal(1),
@@ -9444,14 +9558,14 @@ function sortedUnique5(values) {
 }
 async function readTrustStore(path) {
   if (!await pathExists(path)) return { version: 1, acceptedSources: [] };
-  return trustStoreSchema.parse(JSON.parse(await readFile26(path, "utf8")));
+  return trustStoreSchema.parse(JSON.parse(await readFile27(path, "utf8")));
 }
 async function writeTrustStore(path, store) {
-  await mkdir19(dirname26(path), { recursive: true });
+  await mkdir20(dirname27(path), { recursive: true });
   await writeJsonAtomic(path, trustStoreSchema.parse(store));
 }
 function defaultTrustStorePath() {
-  return process.env.AGENTWHEEL_TRUST_STORE ?? join34(homedir7(), ".agentwheel", "trust.json");
+  return process.env.AGENTWHEEL_TRUST_STORE ?? join35(homedir7(), ".agentwheel", "trust.json");
 }
 
 // src/lifecycle/ownership.ts
@@ -9623,7 +9737,7 @@ async function createGraphSourcePlan(options) {
   const registryClient = new RegistryClient({ workspaceRoot, offline: lockMode, offlineLabel: lockLabel, warn });
   const graph = await resolveDependencyGraph(options.roots, {
     workspaceRoot,
-    cacheRoot: join35(workspaceRoot, ".agentwheel", "cache"),
+    cacheRoot: join36(workspaceRoot, ".agentwheel", "cache"),
     registryClient,
     noDeps: options.noDeps,
     includeSuggestions: options.includeSuggestions,
@@ -9729,7 +9843,7 @@ async function readExistingGraphLock(path) {
   return readGraphLock(path);
 }
 function pathForGraphLock(workspaceRoot, targetKey2, adapter, targetFingerprint) {
-  return join35(workspaceRoot, ".agentwheel", "locks", sanitizePathSegment(targetKey2), sanitizePathSegment(adapter), `${targetFingerprint}.graph-lock.json`);
+  return join36(workspaceRoot, ".agentwheel", "locks", sanitizePathSegment(targetKey2), sanitizePathSegment(adapter), `${targetFingerprint}.graph-lock.json`);
 }
 function sanitizePathSegment(value) {
   return value.replace(/[^a-z0-9._-]+/gi, "-").replace(/^-+|-+$/g, "") || "default";
@@ -9861,7 +9975,7 @@ function targetLabel(target) {
 }
 
 // src/runtime/target.ts
-import { basename as basename20, dirname as dirname28, join as join36, resolve as resolve17 } from "path";
+import { basename as basename21, dirname as dirname29, join as join37, resolve as resolve17 } from "path";
 var runtimeMarkers = [
   { adapter: "openclaw", dirs: [".openclaw", ".clawdbot", ".moltbot"] },
   { adapter: "claude", dirs: [".claude"] },
@@ -9920,6 +10034,9 @@ async function resolveProfileRuntimeTargets(request) {
   if (!profile) {
     throw new Error(`Unknown profile: ${request.profile}`);
   }
+  if (isCompositeWorkspaceProfile(profile)) {
+    throw new Error(`Profile '${request.profile}' is composite and has no direct runtime targets.`);
+  }
   return profile.runtimes.map((runtime) => resolveProfileRuntimeTarget(runtime, config, workspaceRoot, request.installationType));
 }
 function resolveProfileRuntimeTarget(runtime, config, workspaceRoot, installationType) {
@@ -9978,9 +10095,9 @@ async function detectRuntimeTargets(cwd = process.cwd(), adapterFilter) {
   for (const marker of runtimeMarkers) {
     if (adapterFilter && marker.adapter !== adapterFilter) continue;
     for (const dir of marker.dirs) {
-      if (basename20(root) === dir) {
-        matches.push({ adapter: marker.adapter, targetRoot: dirname28(root) });
-      } else if (await pathExists(join36(root, dir))) {
+      if (basename21(root) === dir) {
+        matches.push({ adapter: marker.adapter, targetRoot: dirname29(root) });
+      } else if (await pathExists(join37(root, dir))) {
         matches.push({ adapter: marker.adapter, targetRoot: root });
       }
     }
@@ -10022,7 +10139,7 @@ function dedupeTargets(matches) {
 function runtimeScanRoot(request) {
   const root = resolve17(request.targetRoot ?? request.cwd ?? process.cwd());
   if (request.targetRoot) return root;
-  return runtimeMarkers.some((marker) => marker.dirs.includes(basename20(root))) ? dirname28(root) : root;
+  return runtimeMarkers.some((marker) => marker.dirs.includes(basename21(root))) ? dirname29(root) : root;
 }
 
 // src/lifecycle/profile.ts
@@ -10032,6 +10149,9 @@ async function syncProfile(options) {
   if (!profile) {
     throw new Error(`Unknown profile: ${options.profile}`);
   }
+  if (isCompositeWorkspaceProfile(profile)) {
+    throw new Error(`Composite profile '${options.profile}' must be executed through member delegation.`);
+  }
   const packages = options.source ? [await packageFromSource(options.source, options)] : config.packages;
   if (packages.length === 0) {
     throw new Error("Profile sync needs a source argument or configured packages.");
@@ -10059,6 +10179,7 @@ async function syncProfile(options) {
         rootId: pkg.name,
         source: pkg.source,
         mode: options.mode ?? pkg.mode,
+        version: pkg.version,
         ref: pkg.requestedRef,
         select: pkg.selection ? void 0 : selected ?? normalizeArtifactSelectors(pkg.select, pkg.skills),
         selection: pkg.selection,
@@ -10320,9 +10441,9 @@ function shellQuoteArg(value) {
 }
 
 // src/cli/update-check.ts
-import { mkdir as mkdir21, readFile as readFile27, writeFile as writeFile19 } from "fs/promises";
+import { mkdir as mkdir22, readFile as readFile28, writeFile as writeFile20 } from "fs/promises";
 import { homedir as homedir8 } from "os";
-import { dirname as dirname29, join as join37 } from "path";
+import { dirname as dirname30, join as join38 } from "path";
 var DEFAULT_TTL_MS = 24 * 60 * 60 * 1e3;
 var DEFAULT_TIMEOUT_MS = 300;
 var REGISTRY_URL = "https://registry.npmjs.org/agentwheel";
@@ -10330,7 +10451,7 @@ async function maybeCheckForUpdate(options) {
   if (isDisabled(options)) return;
   const now = options.now?.() ?? /* @__PURE__ */ new Date();
   const ttlMs = options.ttlMs ?? DEFAULT_TTL_MS;
-  const cachePath = options.cachePath ?? join37(homedir8(), ".agentwheel", "update-check.json");
+  const cachePath = options.cachePath ?? join38(homedir8(), ".agentwheel", "update-check.json");
   try {
     const cached = await readCache(cachePath);
     if (cached && now.getTime() - Date.parse(cached.checkedAt) < ttlMs) {
@@ -10367,7 +10488,7 @@ async function fetchLatestVersion(fetchImpl, timeoutMs) {
 }
 async function readCache(path) {
   try {
-    const parsed = JSON.parse(await readFile27(path, "utf8"));
+    const parsed = JSON.parse(await readFile28(path, "utf8"));
     if (typeof parsed.checkedAt !== "string" || typeof parsed.latest !== "string") return void 0;
     return { checkedAt: parsed.checkedAt, latest: parsed.latest };
   } catch {
@@ -10375,8 +10496,8 @@ async function readCache(path) {
   }
 }
 async function writeCache(path, cache) {
-  await mkdir21(dirname29(path), { recursive: true });
-  await writeFile19(path, `${JSON.stringify(cache, null, 2)}
+  await mkdir22(dirname30(path), { recursive: true });
+  await writeFile20(path, `${JSON.stringify(cache, null, 2)}
 `, "utf8");
 }
 function warnIfNewer(latest, current, stderr = process.stderr) {
@@ -10539,13 +10660,13 @@ function isCrossPackageSelector(value) {
 }
 
 // src/model/package-migrate.ts
-import { readFile as readFile28, rename as rename4, writeFile as writeFile20 } from "fs/promises";
-import { join as join39, resolve as resolve19 } from "path";
+import { readFile as readFile29, rename as rename4, writeFile as writeFile21 } from "fs/promises";
+import { join as join40, resolve as resolve19 } from "path";
 import { applyEdits, modify, parse as parse5 } from "jsonc-parser";
 async function migratePackageManifest(root) {
   const packageRoot = resolve19(root);
   for (const name of openPackManifestNames) {
-    const path = join39(packageRoot, name);
+    const path = join40(packageRoot, name);
     if (await pathExists(path)) {
       return { changed: false, to: path, message: `Package already uses ${name}.` };
     }
@@ -10554,18 +10675,18 @@ async function migratePackageManifest(root) {
   if (!legacyName) {
     throw new Error(`No legacy package manifest found at ${packageRoot}`);
   }
-  const from = join39(packageRoot, legacyName);
+  const from = join40(packageRoot, legacyName);
   const toName = legacyName.endsWith(".jsonc") ? "openpack.jsonc" : "openpack.json";
-  const to = join39(packageRoot, toName);
-  const content = await readFile28(from, "utf8");
+  const to = join40(packageRoot, toName);
+  const content = await readFile29(from, "utf8");
   const updated = updateSchemaVersion(content);
   await rename4(from, to);
-  await writeFile20(to, updated, "utf8");
+  await writeFile21(to, updated, "utf8");
   return { changed: true, from, to, message: `Migrated ${legacyName} to ${toName}.` };
 }
 async function firstExistingLegacyManifest(root) {
   for (const name of legacyPackageManifestNames) {
-    if (await pathExists(join39(root, name))) return name;
+    if (await pathExists(join40(root, name))) return name;
   }
   return void 0;
 }
@@ -10583,38 +10704,1248 @@ function updateSchemaVersion(content) {
 
 // src/cli/version.ts
 import { readFileSync } from "fs";
-import { dirname as dirname30, join as join40 } from "path";
+import { dirname as dirname31, join as join41 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var FALLBACK_VERSION = "0.0.0";
 function resolveCliVersion() {
-  let dir = dirname30(fileURLToPath2(import.meta.url));
+  let dir = dirname31(fileURLToPath2(import.meta.url));
   while (true) {
     try {
-      const pkg = JSON.parse(readFileSync(join40(dir, "package.json"), "utf8"));
+      const pkg = JSON.parse(readFileSync(join41(dir, "package.json"), "utf8"));
       if (pkg.name === "agentwheel" && typeof pkg.version === "string") {
         return pkg.version;
       }
     } catch {
     }
-    const parent = dirname30(dir);
+    const parent = dirname31(dir);
     if (parent === dir) return FALLBACK_VERSION;
     dir = parent;
   }
 }
 
-// src/cli/index.ts
-var CLI_VERSION = resolveCliVersion();
-var COMPANION_SKILL_SOURCE = "github:NestDevLab/agentwheel";
-var COMPANION_SKILL_NAME = "agentwheel";
-var planOutputFormats = ["human", "json", "mermaid", "html"];
-var program = new Command();
-program.name("agentwheel").description("Multi-runtime agent artifact orchestrator").version(CLI_VERSION).showSuggestionAfterError(false).option("--no-update-check", "disable npm version update check", false).addHelpText("after", `
-
-Core flow:
-  $ agentwheel add github:org/agent-pack --adapter codex
-  $ agentwheel plan
-  $ agentwheel install
-`);
+// src/version/policy.ts
+import { execFile as execFile5 } from "child_process";
+import { readFile as readFile30 } from "fs/promises";
+import { join as join42, resolve as resolve20 } from "path";
+import { promisify as promisify5 } from "util";
+import { parse as parseJsonc } from "jsonc-parser";
+import { z as z10 } from "zod";
+var execFileAsync5 = promisify5(execFile5);
+var DEFAULT_VERSION_REFRESH_TTL_SECONDS = 86400;
+var cachedVersionSchema = z10.object({
+  version: z10.string().min(1),
+  ref: z10.string().min(1)
+});
+var versionCacheEntrySchema = z10.object({
+  checkedAt: z10.string().datetime(),
+  versions: z10.array(cachedVersionSchema)
+});
+var versionCacheSchema = z10.object({
+  schemaVersion: z10.literal(1),
+  sources: z10.record(z10.string(), versionCacheEntrySchema)
+});
+async function discoverPackageVersions(pkg, workspaceRoot, options = {}) {
+  const now = (options.now ?? (() => /* @__PURE__ */ new Date()))();
+  const ttlSeconds = options.ttlSeconds ?? DEFAULT_VERSION_REFRESH_TTL_SECONDS;
+  const cachePath = versionCachePath(workspaceRoot);
+  const cache = await readVersionCache(cachePath);
+  const cached = cache.sources[pkg.source];
+  const cachedAgeMs = cached ? now.getTime() - new Date(cached.checkedAt).getTime() : Number.POSITIVE_INFINITY;
+  const cachedFresh = cachedAgeMs <= ttlSeconds * 1e3;
+  if (options.offline || cached && cachedFresh && !options.forceRefresh) {
+    return availabilityFromVersions(pkg, cached?.versions ?? [], {
+      checkedAt: cached?.checkedAt ?? null,
+      stale: !cachedFresh,
+      refreshed: false,
+      error: !cached && options.offline ? "No cached version index is available offline." : void 0
+    });
+  }
+  try {
+    const versions = await discoverVersionsFromSource(pkg, workspaceRoot);
+    const checkedAt = now.toISOString();
+    await writeJsonAtomic(cachePath, {
+      schemaVersion: 1,
+      sources: {
+        ...cache.sources,
+        [pkg.source]: { checkedAt, versions }
+      }
+    });
+    return availabilityFromVersions(pkg, versions, {
+      checkedAt,
+      stale: false,
+      refreshed: true
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return availabilityFromVersions(pkg, cached?.versions ?? [], {
+      checkedAt: cached?.checkedAt ?? null,
+      stale: true,
+      refreshed: false,
+      error: message
+    });
+  }
+}
+async function effectiveTrackingRef(pkg, workspaceRoot, options = {}) {
+  if (pkg.mode !== "tracking" || !pkg.version) return { ref: pkg.requestedRef };
+  const availability = await discoverPackageVersions(pkg, workspaceRoot, options);
+  const driverName = pkg.driver === "local" ? inferSourceDriverName(pkg.source) : pkg.driver;
+  return {
+    ref: driverName === "local" ? pkg.requestedRef : availability.latestAllowedRef ?? pkg.requestedRef,
+    availability
+  };
+}
+function availabilityFromVersions(pkg, versions, state) {
+  const sorted = [...versions].sort((a, b) => compareSemverStrings(b.version, a.version));
+  const policy = pkg.version ?? "*";
+  const latestOverall = sorted[0] ?? null;
+  const latestAllowed = sorted.find((candidate) => satisfiesVersionRange(candidate.version, policy)) ?? null;
+  return {
+    source: pkg.source,
+    policy,
+    checkedAt: state.checkedAt,
+    stale: state.stale,
+    refreshed: state.refreshed,
+    latestAllowed: latestAllowed?.version ?? null,
+    latestAllowedRef: latestAllowed?.ref ?? null,
+    latestOverall: latestOverall?.version ?? null,
+    latestOverallRef: latestOverall?.ref ?? null,
+    versions: sorted,
+    ...state.error ? { error: state.error } : {}
+  };
+}
+async function discoverVersionsFromSource(pkg, workspaceRoot) {
+  const driverName = pkg.driver === "local" ? inferSourceDriverName(pkg.source) : pkg.driver;
+  if (driverName === "git") {
+    const tagged = await discoverGitTags(pkg.source, pkg.version);
+    if (tagged.length > 0) return tagged;
+  }
+  if (driverName === "local") {
+    const root = resolve20(workspaceRoot, pkg.source);
+    const manifest2 = await readPackageManifest(root);
+    const current = manifest2 ? [{ version: manifest2.version, ref: pkg.requestedRef ?? root }] : [];
+    try {
+      const { stdout } = await execFileAsync5("git", ["-C", root, "remote", "get-url", "origin"]);
+      return uniqueVersions([
+        ...await discoverGitTagsFromUrl(stdout.trim(), pkg.version, root),
+        ...current
+      ]);
+    } catch {
+      return current;
+    }
+  }
+  const driver = getSourceDriver(driverName);
+  const resolved = await driver.resolve(pkg.source, {
+    cacheRoot: join42(workspaceRoot, ".agentwheel", "cache"),
+    mode: "tracking",
+    ref: pkg.requestedRef
+  });
+  const fetched = await driver.fetch(resolved);
+  const manifest = await readPackageManifest(fetched.resolvedPath);
+  const version = manifest?.version ?? fetched.packageVersion;
+  return version ? [{ version, ref: fetched.requestedRef ?? pkg.requestedRef ?? "HEAD" }] : [];
+}
+async function discoverGitTags(source, policy) {
+  const url = gitUrlFromSource(source);
+  const localRoot = url.startsWith("/") ? url : void 0;
+  return discoverGitTagsFromUrl(url, policy, localRoot);
+}
+async function discoverGitTagsFromUrl(url, policy, localRoot) {
+  const { stdout } = await execFileAsync5("git", ["ls-remote", "--tags", "--refs", url], {
+    maxBuffer: 10 * 1024 * 1024
+  });
+  const byVersion = /* @__PURE__ */ new Map();
+  for (const line of stdout.split(/\r?\n/)) {
+    const match = /^[0-9a-f]+\s+refs\/tags\/(.+)$/.exec(line.trim());
+    if (!match) continue;
+    const tag = match[1];
+    if (!parseSemver(tag)) continue;
+    const version = tag.replace(/^v/, "");
+    const incumbent = byVersion.get(version);
+    if (!incumbent || tag.startsWith("v")) byVersion.set(version, { version, ref: tag });
+  }
+  const candidates = [...byVersion.values()].sort((a, b) => compareSemverStrings(b.version, a.version));
+  const valid = [];
+  let foundOverall = false;
+  let foundAllowed = false;
+  for (const candidate of candidates) {
+    const manifestVersion = await manifestVersionAtRef(url, candidate.ref, localRoot);
+    if (manifestVersion !== candidate.version) continue;
+    valid.push(candidate);
+    foundOverall = true;
+    if (satisfiesVersionRange(candidate.version, policy)) foundAllowed = true;
+    if (foundOverall && foundAllowed) break;
+  }
+  return valid;
+}
+function uniqueVersions(versions) {
+  const byVersion = /* @__PURE__ */ new Map();
+  for (const version of versions) {
+    if (!byVersion.has(version.version)) byVersion.set(version.version, version);
+  }
+  return [...byVersion.values()].sort((a, b) => compareSemverStrings(b.version, a.version));
+}
+async function manifestVersionAtRef(url, ref, localRoot) {
+  if (localRoot) {
+    for (const name of ["openpack.json", "openpack.jsonc"]) {
+      try {
+        const { stdout } = await execFileAsync5("git", ["-C", localRoot, "show", `${ref}:${name}`], {
+          maxBuffer: 1024 * 1024
+        });
+        const parsed = parseJsonc(stdout);
+        if (typeof parsed?.version === "string") return parsed.version.replace(/^v/, "");
+      } catch {
+      }
+    }
+    return null;
+  }
+  const repository = githubRepositoryFromUrl(url);
+  if (!repository) return null;
+  for (const name of ["openpack.json", "openpack.jsonc"]) {
+    const response = await fetch(
+      `https://raw.githubusercontent.com/${repository}/${encodeURIComponent(ref)}/${name}`,
+      { headers: { "user-agent": "agentwheel-version-discovery" } }
+    );
+    if (!response.ok) continue;
+    const parsed = parseJsonc(await response.text());
+    if (typeof parsed?.version === "string") return parsed.version.replace(/^v/, "");
+  }
+  return null;
+}
+function githubRepositoryFromUrl(url) {
+  const match = /^(?:https:\/\/github\.com\/|git@github\.com:)([^/]+\/[^/#]+?)(?:\.git)?$/.exec(url);
+  return match?.[1] ?? null;
+}
+function gitUrlFromSource(source) {
+  if (source.startsWith("github:")) {
+    const repo = source.slice("github:".length).split("#", 1)[0];
+    if (!repo.includes("/")) throw new Error(`Invalid GitHub source: ${source}`);
+    return `https://github.com/${repo}.git`;
+  }
+  if (source.startsWith("git:")) {
+    const rest = source.slice("git:".length);
+    const hashIndex = rest.lastIndexOf("#");
+    return hashIndex >= 0 ? rest.slice(0, hashIndex) : rest;
+  }
+  throw new Error(`Version discovery does not support Git source: ${source}`);
+}
+function versionCachePath(workspaceRoot) {
+  return join42(workspaceRoot, ".agentwheel", "cache", "version-index.json");
+}
+async function readVersionCache(path) {
+  if (!await pathExists(path)) return { schemaVersion: 1, sources: {} };
+  try {
+    return versionCacheSchema.parse(JSON.parse(await readFile30(path, "utf8")));
+  } catch {
+    return { schemaVersion: 1, sources: {} };
+  }
+}
+
+// src/profile/members.ts
+import { execFile as execFile6 } from "child_process";
+import { readFile as readFile31 } from "fs/promises";
+import { join as join43, resolve as resolve21 } from "path";
+import { promisify as promisify6 } from "util";
+import { z as z12 } from "zod";
+
+// src/status/report.ts
+import { z as z11 } from "zod";
+var statusHealthSchema = z11.enum([
+  "PASS",
+  "WARN",
+  "FAIL",
+  "STALE",
+  "DEGRADED",
+  "INCOMPATIBLE",
+  "BUSY"
+]);
+var statusPackageSchema = z11.object({
+  name: z11.string().min(1),
+  source: z11.string().min(1),
+  mode: z11.enum(["pinned", "tracking"]),
+  policy: z11.string().min(1),
+  installed: z11.string().nullable(),
+  locked: z11.string().nullable(),
+  latestAllowed: z11.string().nullable(),
+  latestOverall: z11.string().nullable(),
+  availability: z11.enum(["FRESH", "STALE", "UNKNOWN"]),
+  checkedAt: z11.string().nullable(),
+  error: z11.string().optional(),
+  updateAvailableAllowed: z11.boolean(),
+  updateAvailableOverall: z11.boolean()
+});
+var statusArtifactSchema = z11.object({
+  selector: z11.string().min(1),
+  type: z11.string().min(1),
+  name: z11.string().min(1),
+  installName: z11.string().min(1),
+  packageName: z11.string().nullable(),
+  packageVersion: z11.string().nullable(),
+  hash: z11.string().min(16),
+  installed: z11.boolean()
+});
+var statusTargetSchema = z11.object({
+  adapter: z11.string().min(1),
+  installationType: z11.string().min(1),
+  targetRoot: z11.string().min(1),
+  health: statusHealthSchema,
+  manifestRevision: z11.string().nullable(),
+  manifestEntryCount: z11.number().int().nonnegative(),
+  graphLockPath: z11.string().nullable(),
+  packageCount: z11.number().int().nonnegative(),
+  artifactCount: z11.number().int().nonnegative(),
+  pendingCount: z11.number().int().nonnegative(),
+  driftCount: z11.number().int().nonnegative(),
+  conflictCount: z11.number().int().nonnegative(),
+  error: z11.string().optional(),
+  packages: z11.array(statusPackageSchema),
+  artifacts: z11.array(statusArtifactSchema)
+});
+var statusReportSchema = z11.lazy(() => z11.object({
+  schemaVersion: z11.literal(1),
+  command: z11.literal("status"),
+  agentwheelVersion: z11.string().min(1),
+  generatedAt: z11.string().datetime(),
+  workspace: z11.string().min(1),
+  profile: z11.string().nullable(),
+  health: statusHealthSchema,
+  repository: z11.object({
+    available: z11.boolean(),
+    branch: z11.string().nullable(),
+    head: z11.string().nullable(),
+    upstream: z11.string().nullable(),
+    ahead: z11.number().int().nonnegative(),
+    behind: z11.number().int().nonnegative(),
+    dirtyCount: z11.number().int().nonnegative(),
+    error: z11.string().optional()
+  }),
+  targets: z11.array(statusTargetSchema),
+  members: z11.array(z11.object({
+    id: z11.string().min(1),
+    transport: z11.enum(["local", "ssh"]),
+    workspace: z11.string().min(1),
+    profile: z11.string().min(1),
+    health: statusHealthSchema,
+    agentwheelVersion: z11.string().nullable(),
+    checkedAt: z11.string().nullable(),
+    stale: z11.boolean(),
+    error: z11.string().optional(),
+    report: statusReportSchema.optional()
+  }))
+}));
+var HEALTH_RANK = {
+  PASS: 0,
+  WARN: 1,
+  STALE: 2,
+  DEGRADED: 3,
+  BUSY: 4,
+  INCOMPATIBLE: 5,
+  FAIL: 6
+};
+function worstStatusHealth(values) {
+  return values.reduce(
+    (worst, value) => HEALTH_RANK[value] > HEALTH_RANK[worst] ? value : worst,
+    "PASS"
+  );
+}
+function blocksCompositeApply(health) {
+  return !["PASS", "WARN"].includes(health);
+}
+
+// src/profile/members.ts
+var execFileAsync6 = promisify6(execFile6);
+var memberCacheSchema = z12.object({
+  schemaVersion: z12.literal(1),
+  checkedAt: z12.string().datetime(),
+  report: statusReportSchema
+});
+async function collectCompositeMembers(options) {
+  const chain = [...options.chain ?? [], compositeKey(options.workspaceRoot, options.profileName)];
+  const results = [];
+  for (const member of options.members) {
+    results.push(await collectMember(member, options, chain));
+  }
+  return results;
+}
+async function collectMember(member, options, chain) {
+  const cachePath = memberCachePath(options.workspaceRoot, options.profileName, member.id);
+  const cached = await readMemberCache(cachePath);
+  const ttlSeconds = member.refreshTtlSeconds ?? options.profileTtlSeconds;
+  const ageMs = cached ? Date.now() - new Date(cached.checkedAt).getTime() : Number.POSITIVE_INFINITY;
+  const fresh = ageMs <= ttlSeconds * 1e3;
+  if (options.offline || cached && fresh && !options.refresh) {
+    if (!cached) {
+      return memberFailure(member, "STALE", "No cached member status is available offline.");
+    }
+    return memberFromReport(member, cached.report, {
+      checkedAt: cached.checkedAt,
+      stale: options.offline || !fresh,
+      health: options.offline || !fresh ? worstStatusHealth([cached.report.health, "STALE"]) : cached.report.health
+    });
+  }
+  try {
+    const report = await invokeMemberStatus(member, options.workspaceRoot, chain, {
+      refresh: options.refresh || !fresh,
+      offline: false
+    }, options.cliEntry);
+    const checkedAt = (/* @__PURE__ */ new Date()).toISOString();
+    await writeJsonAtomic(cachePath, { schemaVersion: 1, checkedAt, report });
+    const versionHealth = report.agentwheelVersion === options.cliVersion ? "PASS" : "WARN";
+    return memberFromReport(member, report, {
+      checkedAt,
+      stale: false,
+      health: worstStatusHealth([report.health, versionHealth])
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const incompatible = /Incompatible member status protocol|Unknown option.*--json|Unknown command.*status/i.test(message);
+    if (cached) {
+      return memberFromReport(member, cached.report, {
+        checkedAt: cached.checkedAt,
+        stale: true,
+        health: incompatible ? "INCOMPATIBLE" : "DEGRADED",
+        error: message
+      });
+    }
+    return memberFailure(member, incompatible ? "INCOMPATIBLE" : "FAIL", message);
+  }
+}
+async function invokeMemberStatus(member, parentWorkspace, chain, options, cliEntry = process.argv[1]) {
+  const args = ["--no-update-check", "status", "--profile", member.profile, "--json"];
+  if (options.refresh) args.push("--refresh");
+  if (options.offline) args.push("--offline");
+  const env = { ...process.env, AGENTWHEEL_COMPOSITE_CHAIN: JSON.stringify(chain) };
+  let stdout = "";
+  let stderr = "";
+  try {
+    if (member.transport === "local") {
+      const workspace = resolve21(parentWorkspace, member.workspace);
+      const result = await execFileAsync6(process.execPath, [cliEntry, ...args], {
+        cwd: workspace,
+        env,
+        maxBuffer: 20 * 1024 * 1024
+      });
+      stdout = result.stdout;
+      stderr = result.stderr;
+    } else {
+      const sshArgs = sshArguments(member);
+      const remoteArgs = [
+        `cd ${shellQuote(member.workspace)}`,
+        "&&",
+        `AGENTWHEEL_COMPOSITE_CHAIN=${shellQuote(JSON.stringify(chain))}`,
+        "agentwheel",
+        ...args.map(shellQuote)
+      ];
+      const result = await execFileAsync6("ssh", [...sshArgs, remoteArgs.join(" ")], {
+        env,
+        maxBuffer: 20 * 1024 * 1024
+      });
+      stdout = result.stdout;
+      stderr = result.stderr;
+    }
+  } catch (error) {
+    if (typeof error === "object" && error !== null) {
+      stdout = "stdout" in error ? String(error.stdout ?? "") : "";
+      stderr = "stderr" in error ? String(error.stderr ?? "") : "";
+    }
+    if (!stdout.trim()) throw error;
+  }
+  try {
+    return statusReportSchema.parse(JSON.parse(stdout));
+  } catch (error) {
+    const detail = stderr.trim() || (error instanceof Error ? error.message : String(error));
+    throw new Error(`Incompatible member status protocol for ${member.id}: ${detail}`);
+  }
+}
+async function runMemberAgentwheel(member, parentWorkspace, args, chain) {
+  const env = { ...process.env, AGENTWHEEL_COMPOSITE_CHAIN: JSON.stringify(chain) };
+  try {
+    if (member.transport === "local") {
+      const result2 = await execFileAsync6(
+        process.execPath,
+        [process.argv[1], "--no-update-check", ...args],
+        {
+          cwd: resolve21(parentWorkspace, member.workspace),
+          env,
+          maxBuffer: 20 * 1024 * 1024
+        }
+      );
+      return { stdout: result2.stdout, stderr: result2.stderr };
+    }
+    const remoteArgs = [
+      `cd ${shellQuote(member.workspace)}`,
+      "&&",
+      `AGENTWHEEL_COMPOSITE_CHAIN=${shellQuote(JSON.stringify(chain))}`,
+      "agentwheel",
+      "--no-update-check",
+      ...args.map(shellQuote)
+    ];
+    const result = await execFileAsync6("ssh", [...sshArguments(member), remoteArgs.join(" ")], {
+      env,
+      maxBuffer: 20 * 1024 * 1024
+    });
+    return { stdout: result.stdout, stderr: result.stderr };
+  } catch (error) {
+    const detail = commandErrorDetail(error);
+    if (/lock|busy|timed out waiting/i.test(detail)) {
+      throw new Error(`BUSY ${member.id}: ${detail}`);
+    }
+    throw new Error(`Member ${member.id} command failed: ${detail}`);
+  }
+}
+function sshArguments(member) {
+  const destination = member.user ? `${member.user}@${member.host}` : member.host;
+  return [
+    ...member.port ? ["-p", String(member.port)] : [],
+    ...member.identityFile ? ["-i", member.identityFile] : [],
+    "--",
+    destination
+  ];
+}
+function shellQuote(value) {
+  return `'${value.replaceAll("'", `'"'"'`)}'`;
+}
+function commandErrorDetail(error) {
+  if (typeof error === "object" && error !== null) {
+    const stderr = "stderr" in error ? String(error.stderr).trim() : "";
+    if (stderr) return stderr;
+  }
+  return error instanceof Error ? error.message : String(error);
+}
+function memberFromReport(member, report, state) {
+  return {
+    id: member.id,
+    transport: member.transport,
+    workspace: member.workspace,
+    profile: member.profile,
+    health: state.health,
+    agentwheelVersion: report.agentwheelVersion,
+    checkedAt: state.checkedAt,
+    stale: state.stale,
+    ...state.error ? { error: state.error } : {},
+    report
+  };
+}
+function memberFailure(member, health, error) {
+  return {
+    id: member.id,
+    transport: member.transport,
+    workspace: member.workspace,
+    profile: member.profile,
+    health,
+    agentwheelVersion: null,
+    checkedAt: null,
+    stale: true,
+    error
+  };
+}
+function memberCachePath(workspaceRoot, profileName, memberId) {
+  return join43(workspaceRoot, ".agentwheel", "cache", "member-status", profileName, `${memberId}.json`);
+}
+async function readMemberCache(path) {
+  if (!await pathExists(path)) return void 0;
+  try {
+    return memberCacheSchema.parse(JSON.parse(await readFile31(path, "utf8")));
+  } catch {
+    return void 0;
+  }
+}
+function parseCompositeChain() {
+  const value = process.env.AGENTWHEEL_COMPOSITE_CHAIN;
+  if (!value) return [];
+  try {
+    return z12.array(z12.string()).parse(JSON.parse(value));
+  } catch {
+    throw new Error("Invalid AGENTWHEEL_COMPOSITE_CHAIN protocol value.");
+  }
+}
+function assertNoCompositeCycle(workspaceRoot, profileName, chain) {
+  const key = compositeKey(workspaceRoot, profileName);
+  if (chain.includes(key)) {
+    throw new Error(`Composite profile cycle detected: ${[...chain, key].join(" -> ")}`);
+  }
+}
+function compositeKey(workspaceRoot, profileName) {
+  return `${resolve21(workspaceRoot)}#${profileName}`;
+}
+
+// src/status/repository.ts
+import { execFile as execFile7 } from "child_process";
+import { promisify as promisify7 } from "util";
+var execFileAsync7 = promisify7(execFile7);
+async function collectRepositoryStatus(workspaceRoot) {
+  try {
+    const { stdout } = await execFileAsync7(
+      "git",
+      ["-C", workspaceRoot, "status", "--porcelain=v2", "--branch"],
+      { maxBuffer: 10 * 1024 * 1024 }
+    );
+    const lines = stdout.split(/\r?\n/).filter(Boolean);
+    const branch = valueAfter(lines, "# branch.head ");
+    const head = valueAfter(lines, "# branch.oid ");
+    const upstream = valueAfter(lines, "# branch.upstream ");
+    const ab = valueAfter(lines, "# branch.ab ");
+    const match = ab ? /^\+(\d+)\s+-(\d+)$/.exec(ab) : void 0;
+    return {
+      available: true,
+      branch: branch === "(detached)" ? null : branch,
+      head: head === "(initial)" ? null : head,
+      upstream,
+      ahead: match ? Number(match[1]) : 0,
+      behind: match ? Number(match[2]) : 0,
+      dirtyCount: lines.filter((line) => !line.startsWith("# ")).length
+    };
+  } catch (error) {
+    return {
+      available: false,
+      branch: null,
+      head: null,
+      upstream: null,
+      ahead: 0,
+      behind: 0,
+      dirtyCount: 0,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function valueAfter(lines, prefix) {
+  return lines.find((line) => line.startsWith(prefix))?.slice(prefix.length).trim() ?? null;
+}
+
+// src/catalogue/client.ts
+import { createHash as createHash11 } from "crypto";
+import { readFile as readFile32, rm as rm11 } from "fs/promises";
+import { homedir as homedir9 } from "os";
+import { join as join44 } from "path";
+
+// src/model/catalogue.ts
+import { z as z13 } from "zod";
+var searchScopeSchema = z13.enum(["all", "registry", "enriched", "vercel"]);
+var searchTypeSchema = z13.enum(["package", "skill", "plugin", "mcp", "adapter"]);
+var searchEcosystemSchema = z13.enum([
+  "official",
+  "openpack",
+  "mcp-registry",
+  "clawhub",
+  "skillkit",
+  "vercel"
+]);
+var catalogueProvenanceSchema = z13.enum(["registry", "enriched", "vercel"]);
+var installabilitySchema = z13.enum(["registry", "source", "informational"]);
+var nullableString = z13.string().nullable();
+var nullableStringArray = z13.array(z13.string()).nullable();
+var enrichedCatalogueEntrySchema = z13.object({
+  id: z13.string().min(1),
+  name: z13.string().min(1),
+  ecosystem: searchEcosystemSchema.nullable(),
+  type: searchTypeSchema.nullable(),
+  description: nullableString,
+  tags: nullableStringArray,
+  source: nullableString,
+  installCommand: nullableString,
+  repoUrl: nullableString,
+  homepageUrl: nullableString.optional(),
+  homepageLinkLabel: nullableString.optional(),
+  stars: z13.number().finite().nullable().optional(),
+  lastPush: nullableString.optional(),
+  archived: z13.boolean().nullable(),
+  provides: nullableStringArray,
+  version: nullableString,
+  featured: z13.boolean().nullable().optional()
+});
+var enrichedCatalogueSchema = z13.object({
+  schemaVersion: z13.literal(1),
+  generatedAt: z13.string().datetime(),
+  entries: z13.array(enrichedCatalogueEntrySchema)
+}).superRefine((value, context) => {
+  const seen = /* @__PURE__ */ new Set();
+  value.entries.forEach((entry, index) => {
+    if (seen.has(entry.id)) {
+      context.addIssue({
+        code: "custom",
+        path: ["entries", index, "id"],
+        message: `duplicate catalogue id: ${entry.id}`
+      });
+    }
+    seen.add(entry.id);
+  });
+});
+var vercelCatalogueEntrySchema = z13.object({
+  o: z13.string().min(1),
+  r: z13.string().min(1),
+  s: z13.string().min(1),
+  d: z13.string().nullable().optional()
+});
+var vercelCatalogueSchema = z13.object({
+  schemaVersion: z13.literal(1),
+  generatedAt: z13.string().datetime(),
+  count: z13.number().int().nonnegative(),
+  entries: z13.array(vercelCatalogueEntrySchema)
+}).superRefine((value, context) => {
+  if (value.count !== value.entries.length) {
+    context.addIssue({
+      code: "custom",
+      path: ["count"],
+      message: `count must equal entries length (${value.entries.length})`
+    });
+  }
+  const seen = /* @__PURE__ */ new Set();
+  value.entries.forEach((entry, index) => {
+    const id = `${entry.o}/${entry.r}/${entry.s}`;
+    if (seen.has(id)) {
+      context.addIssue({
+        code: "custom",
+        path: ["entries", index],
+        message: `duplicate Vercel catalogue id: ${id}`
+      });
+    }
+    seen.add(id);
+  });
+});
+var catalogueCacheSchema = z13.object({
+  version: z13.literal(1),
+  fetchedAt: z13.string().datetime(),
+  sources: z13.tuple([z13.string().url(), z13.string().url()]),
+  enriched: enrichedCatalogueSchema,
+  vercel: vercelCatalogueSchema
+});
+var catalogueCacheEnvelopeSchema = z13.object({
+  version: z13.literal(1),
+  fetchedAt: z13.string().datetime(),
+  sources: z13.tuple([z13.string().url(), z13.string().url()]),
+  contentHash: z13.string().regex(/^[a-f0-9]{64}$/).optional(),
+  enriched: z13.unknown(),
+  vercel: z13.unknown()
+});
+var searchResultSchema = z13.object({
+  id: z13.string().min(1),
+  name: z13.string().min(1),
+  description: z13.string(),
+  type: searchTypeSchema,
+  ecosystem: searchEcosystemSchema.optional(),
+  tags: z13.array(z13.string()),
+  provides: z13.array(z13.string()),
+  source: z13.string().min(1).optional(),
+  repoUrl: z13.string().min(1).optional(),
+  installCommand: z13.string().min(1).optional(),
+  installability: installabilitySchema,
+  provenances: z13.array(catalogueProvenanceSchema).min(1),
+  score: z13.number().int().nonnegative(),
+  matchedFields: z13.array(z13.string())
+});
+var searchResponseSchema = z13.object({
+  schemaVersion: z13.literal(1),
+  query: z13.string(),
+  scope: searchScopeSchema,
+  fromCache: z13.boolean(),
+  results: z13.array(searchResultSchema)
+});
+
+// src/catalogue/client.ts
+var DEFAULT_ENRICHED_CATALOGUE_URL = "https://raw.githubusercontent.com/NestDevLab/agentwheel-registry/main/catalogue-data.json";
+var DEFAULT_VERCEL_CATALOGUE_URL = "https://raw.githubusercontent.com/NestDevLab/agentwheel-registry/main/catalogue-vercel-index.json";
+var DEFAULT_CATALOGUE_TTL_MS = 24 * 60 * 60 * 1e3;
+var MAX_CATALOGUE_PAYLOAD_BYTES = 32 * 1024 * 1024;
+var CatalogueClient = class {
+  constructor(options = {}) {
+    this.options = options;
+    this.cachePath = options.cachePath ?? defaultCatalogueCachePath();
+    this.now = options.now ?? (() => /* @__PURE__ */ new Date());
+    this.fetchImpl = options.fetch ?? fetch;
+    this.sources = [
+      options.enrichedUrl ?? DEFAULT_ENRICHED_CATALOGUE_URL,
+      options.vercelUrl ?? DEFAULT_VERCEL_CATALOGUE_URL
+    ];
+  }
+  options;
+  cachePath;
+  now;
+  fetchImpl;
+  sources;
+  async getIndex(options = {}) {
+    const cached = await this.readCache();
+    const usableCache = cached && sameSources2(cached.sources, this.sources) ? cached : void 0;
+    const expired = usableCache ? this.isExpired(usableCache) : false;
+    if (this.options.offline) {
+      if (!usableCache) {
+        throw new Error("Offline catalogue cache is missing. Run without --offline first.");
+      }
+      const stale = expired;
+      this.options.warn?.(
+        stale ? "Offline: using stale catalogue cache because refresh is disabled." : "Offline: using cached catalogue data."
+      );
+      return this.fromCache(usableCache, stale);
+    }
+    if (!options.refresh && usableCache && !expired) {
+      return this.fromCache(usableCache, false);
+    }
+    try {
+      const [enriched, vercel] = await Promise.all([
+        this.fetchJson(this.sources[0], enrichedCatalogueSchema),
+        this.fetchJson(this.sources[1], vercelCatalogueSchema)
+      ]);
+      const fetchedAt = this.now().toISOString();
+      const cache = {
+        version: 1,
+        fetchedAt,
+        sources: this.sources,
+        enriched,
+        vercel
+      };
+      const cacheFile = {
+        ...cache,
+        contentHash: catalogueContentHash(enriched, vercel)
+      };
+      await writeJsonAtomic(this.cachePath, cacheFile);
+      return { enriched, vercel, sources: this.sources, fetchedAt, fromCache: false, stale: false };
+    } catch (error) {
+      if (!usableCache) throw error;
+      const reason = error instanceof Error ? error.message : String(error);
+      this.options.warn?.(`Catalogue refresh failed; using stale catalogue cache: ${reason}`);
+      return this.fromCache(usableCache, true);
+    }
+  }
+  async clearCache() {
+    await rm11(this.cachePath, { force: true });
+  }
+  async readCache() {
+    if (!await pathExists(this.cachePath)) return void 0;
+    try {
+      const value = JSON.parse(await readFile32(this.cachePath, "utf8"));
+      const envelope = catalogueCacheEnvelopeSchema.parse(value);
+      if (envelope.contentHash) {
+        const contentHash = catalogueContentHash(envelope.enriched, envelope.vercel);
+        if (contentHash !== envelope.contentHash) {
+          throw new Error("catalogue cache integrity check failed");
+        }
+        return envelope;
+      }
+      return catalogueCacheSchema.parse(value);
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      this.options.warn?.(`Ignoring invalid catalogue cache: ${reason}`);
+      return void 0;
+    }
+  }
+  isExpired(cache) {
+    const ttlMs = this.options.ttlMs ?? DEFAULT_CATALOGUE_TTL_MS;
+    return this.now().getTime() - new Date(cache.fetchedAt).getTime() > ttlMs;
+  }
+  fromCache(cache, stale) {
+    return {
+      enriched: cache.enriched,
+      vercel: cache.vercel,
+      sources: cache.sources,
+      fetchedAt: cache.fetchedAt,
+      fromCache: true,
+      stale
+    };
+  }
+  async fetchJson(source, schema) {
+    const response = await this.fetchImpl(source);
+    if (!response.ok) {
+      throw new Error(`Catalogue source failed (${response.status}): ${source}`);
+    }
+    const declaredLength = response.headers.get("content-length");
+    if (declaredLength !== null) {
+      const bytes = Number(declaredLength);
+      if (Number.isFinite(bytes) && bytes > MAX_CATALOGUE_PAYLOAD_BYTES) {
+        throw new Error(`Catalogue payload exceeds 32 MiB limit: ${source}`);
+      }
+    }
+    const payload = await response.arrayBuffer();
+    if (payload.byteLength > MAX_CATALOGUE_PAYLOAD_BYTES) {
+      throw new Error(`Catalogue payload exceeds 32 MiB limit: ${source}`);
+    }
+    let value;
+    try {
+      value = JSON.parse(new TextDecoder().decode(payload));
+    } catch {
+      throw new Error(`Catalogue source returned invalid JSON: ${source}`);
+    }
+    return schema.parse(value);
+  }
+};
+function defaultCatalogueCachePath() {
+  return join44(homedir9(), ".agentwheel", "catalogue-cache.json");
+}
+function sameSources2(a, b) {
+  return a.length === b.length && a.every((source, index) => source === b[index]);
+}
+function catalogueContentHash(enriched, vercel) {
+  return createHash11("sha256").update(JSON.stringify({ enriched, vercel })).digest("hex");
+}
+
+// src/search/index.ts
+var SCORE = {
+  exactName: 1e4,
+  namePrefix: 5e3,
+  namePhrase: 3e3,
+  tagProvidesPhrase: 2e3,
+  descriptionPhrase: 1e3,
+  typeEcosystemPhrase: 800,
+  repositoryPhrase: 400,
+  nameToken: 300,
+  nameTokenPrefix: 200,
+  tagProvidesToken: 180,
+  descriptionToken: 80,
+  typeEcosystemToken: 60,
+  repositoryToken: 40,
+  allTerms: 500
+};
+var PROVENANCE_ORDER = ["registry", "enriched", "vercel"];
+var MATCHED_FIELD_ORDER = ["name", "tags", "provides", "description", "type", "ecosystem", "repository"];
+function buildSearchEntries(input) {
+  const enriched = catalogueEntries(input.enriched);
+  const vercel = catalogueEntries(input.vercel);
+  assertUniqueIdentities(enriched.map((entry) => entry.id), "enriched catalogue");
+  assertUniqueIdentities(vercel.map((entry) => `${entry.o}/${entry.r}/${entry.s}`), "Vercel catalogue");
+  const records = [
+    ...(input.registry ?? []).map(normalizeRegistryEntry),
+    ...enriched.map(normalizeEnrichedEntry),
+    ...vercel.map(normalizeVercelEntry)
+  ];
+  const byId = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    const existing = byId.get(record.id);
+    byId.set(record.id, existing ? mergeEntry(existing, record) : record);
+  }
+  for (const [registryId, registryEntry] of [...byId]) {
+    if (registryEntry.provenances.length !== 1 || registryEntry.provenances[0] !== "registry" || registryEntry.hasRegistrySelectors || !registryEntry.source) {
+      continue;
+    }
+    const canonicalSource = canonicalizeSource(registryEntry.source);
+    const candidates = [...byId.entries()].filter(
+      ([candidateId2, candidate2]) => candidateId2 !== registryId && !candidate2.provenances.includes("registry") && candidate2.name === registryEntry.name && candidate2.source !== void 0 && canonicalizeSource(candidate2.source) === canonicalSource
+    );
+    if (candidates.length !== 1) continue;
+    const [candidateId, candidate] = candidates[0];
+    byId.set(candidateId, mergeEntry(registryEntry, candidate, candidateId));
+    byId.delete(registryId);
+  }
+  return [...byId.values()].sort(compareStableEntries);
+}
+function searchEntries(entries, query, options = {}) {
+  const normalizedQuery = normalizeSearchText(query);
+  const queryTokens = tokenizeSearchText(query);
+  if (!normalizedQuery || queryTokens.length === 0) return [];
+  const results = entries.filter((entry) => options.includeArchived || !entry.archived).filter((entry) => options.type === void 0 || entry.type === options.type).filter((entry) => options.ecosystem === void 0 || entry.ecosystem === options.ecosystem).map((entry) => ({ entry, result: scoreEntry(entry, normalizedQuery, queryTokens) })).filter(({ result }) => result.score > 0).sort(
+    (a, b) => b.result.score - a.result.score || Number(b.entry.featured) - Number(a.entry.featured) || (b.entry.stars ?? Number.NEGATIVE_INFINITY) - (a.entry.stars ?? Number.NEGATIVE_INFINITY) || compareText(b.entry.lastPush ?? "", a.entry.lastPush ?? "") || compareText(normalizeSearchText(a.result.name), normalizeSearchText(b.result.name)) || compareText(a.result.id, b.result.id)
+  ).map(({ result }) => result);
+  const limit = options.limit === void 0 ? 20 : Math.min(100, Math.max(0, Math.trunc(options.limit)));
+  return results.slice(0, limit);
+}
+function normalizeSearchText(value) {
+  return value.normalize("NFKC").toLowerCase().replace(/[^\p{L}\p{N}]+/gu, " ").trim().replace(/\s+/g, " ");
+}
+function tokenizeSearchText(value) {
+  const normalized = normalizeSearchText(value);
+  return normalized ? [...new Set(normalized.split(" "))] : [];
+}
+function normalizeRegistryEntry(entry) {
+  return {
+    id: `registry:${entry.name}`,
+    name: entry.name,
+    description: entry.description,
+    type: entry.type,
+    ecosystem: inferEcosystem(entry.source),
+    tags: sortedUniqueStrings(entry.tags),
+    provides: [],
+    source: entry.source,
+    installCommand: `npx agentwheel install ${shellQuote2(entry.name)}`,
+    installability: "registry",
+    provenances: ["registry"],
+    archived: false,
+    featured: false,
+    alternateDescriptions: [],
+    descriptionRank: 2,
+    hasRegistrySelectors: Boolean(entry.select?.length || entry.skills?.length)
+  };
+}
+function normalizeEnrichedEntry(entry) {
+  const source = nonEmpty(entry.source);
+  const installCommand = enrichedInstallCommand(entry, source);
+  return {
+    id: entry.id,
+    name: entry.name,
+    description: entry.description ?? "",
+    type: entry.type ?? inferType(entry.ecosystem),
+    ecosystem: entry.ecosystem ?? void 0,
+    tags: sortedUniqueStrings(entry.tags ?? []),
+    provides: sortedUniqueStrings(entry.provides ?? []),
+    source,
+    repoUrl: nonEmpty(entry.repoUrl),
+    installCommand,
+    installability: source || installCommand ? "source" : "informational",
+    provenances: ["enriched"],
+    archived: entry.archived ?? false,
+    featured: entry.featured ?? false,
+    stars: entry.stars ?? void 0,
+    lastPush: nonEmpty(entry.lastPush),
+    alternateDescriptions: [],
+    descriptionRank: 3,
+    hasRegistrySelectors: false
+  };
+}
+function normalizeVercelEntry(entry) {
+  const path = `${entry.o}/${entry.r}/${entry.s}`;
+  const source = `vercel:skills.sh/${path}`;
+  return {
+    id: `vercel:${path}`,
+    name: entry.s,
+    description: entry.d ?? "",
+    type: "skill",
+    ecosystem: "vercel",
+    tags: [],
+    provides: ["skills"],
+    source,
+    repoUrl: `https://github.com/${entry.o}/${entry.r}`,
+    installCommand: `npx agentwheel install ${shellQuote2(source)}`,
+    installability: "source",
+    provenances: ["vercel"],
+    archived: false,
+    featured: false,
+    alternateDescriptions: [],
+    descriptionRank: 1,
+    hasRegistrySelectors: false
+  };
+}
+function mergeEntry(first, second, id = first.id) {
+  const primary = second.description && second.descriptionRank > first.descriptionRank ? second : first;
+  const secondary = primary === first ? second : first;
+  const descriptions = uniqueStrings([
+    primary.description,
+    ...primary.alternateDescriptions,
+    secondary.description,
+    ...secondary.alternateDescriptions
+  ]).filter(Boolean);
+  const description = descriptions[0] ?? "";
+  return {
+    id,
+    name: first.name || second.name,
+    description,
+    type: first.type ?? second.type,
+    ecosystem: first.ecosystem ?? second.ecosystem,
+    tags: sortedUniqueStrings([...first.tags, ...second.tags]),
+    provides: sortedUniqueStrings([...first.provides, ...second.provides]),
+    source: first.source ?? second.source,
+    repoUrl: first.repoUrl ?? second.repoUrl,
+    installCommand: first.installCommand ?? second.installCommand,
+    installability: betterInstallability(first.installability, second.installability),
+    provenances: PROVENANCE_ORDER.filter(
+      (provenance) => first.provenances.includes(provenance) || second.provenances.includes(provenance)
+    ),
+    archived: first.archived || second.archived,
+    featured: first.featured || second.featured,
+    stars: maxDefined(first.stars, second.stars),
+    lastPush: maxText(first.lastPush, second.lastPush),
+    alternateDescriptions: descriptions.slice(1),
+    descriptionRank: Math.max(first.descriptionRank, second.descriptionRank),
+    hasRegistrySelectors: first.hasRegistrySelectors || second.hasRegistrySelectors
+  };
+}
+function scoreEntry(entry, query, queryTokens) {
+  let score = 0;
+  const matched = /* @__PURE__ */ new Set();
+  const name = normalizeSearchText(entry.name);
+  const descriptions = [entry.description, ...entry.alternateDescriptions].map(normalizeSearchText);
+  const tags = entry.tags.map(normalizeSearchText);
+  const provides = entry.provides.map(normalizeSearchText);
+  const type = normalizeSearchText(entry.type);
+  const ecosystem = normalizeSearchText(entry.ecosystem ?? "");
+  const repositories = [entry.source ?? "", entry.repoUrl ?? ""].map(normalizeSearchText);
+  if (name === query) {
+    score += SCORE.exactName;
+    matched.add("name");
+  } else if (name.startsWith(query)) {
+    score += SCORE.namePrefix;
+    matched.add("name");
+  } else if (name.includes(query)) {
+    score += SCORE.namePhrase;
+    matched.add("name");
+  }
+  const tagsPhraseMatch = matchesPhrase(tags, query);
+  const providesPhraseMatch = matchesPhrase(provides, query);
+  if (tagsPhraseMatch || providesPhraseMatch) {
+    score += SCORE.tagProvidesPhrase;
+    if (tagsPhraseMatch) matched.add("tags");
+    if (providesPhraseMatch) matched.add("provides");
+  }
+  if (matchesPhrase(descriptions, query)) {
+    score += SCORE.descriptionPhrase;
+    matched.add("description");
+  }
+  const typePhraseMatch = type.includes(query);
+  const ecosystemPhraseMatch = ecosystem.includes(query);
+  if (typePhraseMatch || ecosystemPhraseMatch) {
+    score += SCORE.typeEcosystemPhrase;
+    if (typePhraseMatch) matched.add("type");
+    if (ecosystemPhraseMatch) matched.add("ecosystem");
+  }
+  if (matchesPhrase(repositories, query)) {
+    score += SCORE.repositoryPhrase;
+    matched.add("repository");
+  }
+  const nameTokens = name.split(" ");
+  const tagTokenText = tags.join(" ");
+  const provideTokenText = provides.join(" ");
+  const descriptionTokenText = descriptions.join(" ");
+  const repositoryTokenText = repositories.join(" ");
+  let allTermsCovered = true;
+  for (const token of queryTokens) {
+    const nameTokenMatch = includesToken(name, token);
+    if (nameTokenMatch) {
+      score += SCORE.nameToken;
+      matched.add("name");
+    } else if (nameTokens.some((candidate) => candidate.startsWith(token))) {
+      score += SCORE.nameTokenPrefix;
+      matched.add("name");
+    }
+    const tagTokenMatch = includesToken(tagTokenText, token);
+    const provideTokenMatch = includesToken(provideTokenText, token);
+    if (tagTokenMatch || provideTokenMatch) {
+      score += SCORE.tagProvidesToken;
+      if (tagTokenMatch) matched.add("tags");
+      if (provideTokenMatch) matched.add("provides");
+    }
+    const descriptionTokenMatch = includesToken(descriptionTokenText, token);
+    if (descriptionTokenMatch) {
+      score += SCORE.descriptionToken;
+      matched.add("description");
+    }
+    const typeTokenMatch = includesToken(type, token);
+    const ecosystemTokenMatch = includesToken(ecosystem, token);
+    if (typeTokenMatch || ecosystemTokenMatch) {
+      score += SCORE.typeEcosystemToken;
+      if (typeTokenMatch) matched.add("type");
+      if (ecosystemTokenMatch) matched.add("ecosystem");
+    }
+    const repositoryTokenMatch = includesToken(repositoryTokenText, token);
+    if (repositoryTokenMatch) {
+      score += SCORE.repositoryToken;
+      matched.add("repository");
+    }
+    if (!nameTokenMatch && !tagTokenMatch && !provideTokenMatch && !descriptionTokenMatch && !typeTokenMatch && !ecosystemTokenMatch && !repositoryTokenMatch) {
+      allTermsCovered = false;
+    }
+  }
+  if (allTermsCovered) {
+    score += SCORE.allTerms;
+  }
+  return {
+    id: entry.id,
+    name: entry.name,
+    description: entry.description,
+    type: entry.type,
+    ...entry.ecosystem ? { ecosystem: entry.ecosystem } : {},
+    tags: entry.tags,
+    provides: entry.provides,
+    ...entry.source ? { source: entry.source } : {},
+    ...entry.repoUrl ? { repoUrl: entry.repoUrl } : {},
+    ...entry.installCommand ? { installCommand: entry.installCommand } : {},
+    installability: entry.installability,
+    provenances: entry.provenances,
+    score,
+    matchedFields: MATCHED_FIELD_ORDER.filter((field) => matched.has(field))
+  };
+}
+function catalogueEntries(catalogue) {
+  if (!catalogue) return [];
+  return Array.isArray(catalogue) ? catalogue : catalogue.entries;
+}
+function canonicalizeSource(source) {
+  const value = source.normalize("NFKC").trim();
+  const github = value.match(
+    /^(?:github:|git:(?:git\+)?https?:\/\/github\.com\/|(?:git\+)?https?:\/\/github\.com\/)([^/#]+)\/([^#]+?)(?:#(.*))?$/i
+  );
+  if (github) {
+    const owner = github[1].toLowerCase();
+    const repository = github[2].replace(/\.git$/i, "").replace(/\/+$/, "").toLowerCase();
+    const ref = github[3];
+    return `github:${owner}/${repository}${ref === void 0 ? "" : `#${ref}`}`;
+  }
+  return value.replace(/\/+$/, "");
+}
+function inferEcosystem(source) {
+  const canonical = canonicalizeSource(source);
+  if (canonical.startsWith("vercel:")) return "vercel";
+  if (canonical.startsWith("mcp-registry:")) return "mcp-registry";
+  if (canonical.startsWith("clawhub:")) return "clawhub";
+  if (canonical.startsWith("skillkit:")) return "skillkit";
+  return void 0;
+}
+function inferType(ecosystem) {
+  if (ecosystem === "vercel" || ecosystem === "skillkit") return "skill";
+  if (ecosystem === "mcp-registry") return "mcp";
+  if (ecosystem === "clawhub") return "plugin";
+  return "package";
+}
+function betterInstallability(a, b) {
+  const rank = { registry: 3, source: 2, informational: 1 };
+  return rank[a] >= rank[b] ? a : b;
+}
+function nonEmpty(value) {
+  return value?.trim() ? value : void 0;
+}
+function uniqueStrings(values) {
+  return [...new Set(values)];
+}
+function sortedUniqueStrings(values) {
+  return uniqueStrings(values).sort(compareText);
+}
+function enrichedInstallCommand(entry, source) {
+  const catalogueCommand = nonEmpty(entry.installCommand);
+  if (!source) return catalogueCommand;
+  if (entry.ecosystem === "mcp-registry" || entry.ecosystem === "clawhub") {
+    return catalogueCommand ?? `npx agentwheel install ${shellQuote2(source)}`;
+  }
+  return `npx agentwheel install ${shellQuote2(source)}`;
+}
+function shellQuote2(value) {
+  return `'${value.replaceAll("'", `'"'"'`)}'`;
+}
+function matchesPhrase(fields, query) {
+  return fields.some((field) => field.includes(query));
+}
+function compareStableEntries(a, b) {
+  return compareText(normalizeSearchText(a.name), normalizeSearchText(b.name)) || compareText(a.id, b.id);
+}
+function maxDefined(a, b) {
+  if (a === void 0) return b;
+  if (b === void 0) return a;
+  return Math.max(a, b);
+}
+function maxText(a, b) {
+  if (a === void 0) return b;
+  if (b === void 0) return a;
+  return a >= b ? a : b;
+}
+function assertUniqueIdentities(ids, label) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const id of ids) {
+    if (seen.has(id)) throw new Error(`Duplicate ${label} id: ${id}`);
+    seen.add(id);
+  }
+}
+function compareText(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+function includesToken(normalizedText, token) {
+  return normalizedText === token || normalizedText.startsWith(`${token} `) || normalizedText.endsWith(` ${token}`) || normalizedText.includes(` ${token} `);
+}
+
+// src/cli/index.ts
+var CLI_VERSION = resolveCliVersion();
+var COMPANION_SKILL_SOURCE = "github:NestDevLab/agentwheel";
+var COMPANION_SKILL_NAME = "agentwheel";
+var planOutputFormats = ["human", "json", "mermaid", "html"];
+var program = new Command();
+program.name("agentwheel").description("Multi-runtime agent artifact orchestrator").version(CLI_VERSION).showSuggestionAfterError(false).option("--no-update-check", "disable npm version update check", false).addHelpText("after", `
+
+Core flow:
+  $ agentwheel add github:org/agent-pack --adapter codex
+  $ agentwheel plan
+  $ agentwheel install
+`);
 program.command("init").description("initialize an agentwheel workspace or package").argument("[kind]", "workspace or package", "workspace").option("-t, --target-root <path>", "workspace root", process.cwd()).option("--fleet-example", "scaffold example agents and profiles in workspace config", false).action(async (kind, options) => {
   const root = normalizeTargetRoot(options.targetRoot);
   if (kind === "package") {
@@ -10633,7 +11964,7 @@ program.command("init").description("initialize an agentwheel workspace or packa
   if (bootstrapPackage) console.log("Auto-added the agentwheel bootstrap skill for openclaw.");
   console.log(nextInstallNudge());
 });
-program.command("add").description("add a package to .agentwheel/config.json without touching runtimes").argument("<source>", "package source").option("--driver <driver>", "source driver (local, git, skillkit, vercel-skills, mcp-registry, or clawhub)").option("--adapter <adapter>", "built-in adapter", "openclaw").option("-i, --installation-type <type>", "installation type (for example local or user)").option("--user", "shortcut for --installation-type user and home-scoped state", false).option("--local", "shortcut for --installation-type local", false).option("--adapter-config <path>", "adapter JSON/JSONC file").option("--adapter-module <path>", "local programmatic adapter module").option("--allow-adapter-code", "allow loading local adapter code", false).option("-t, --target-root <path>", "workspace root").option("--mode <mode>", "pinned or tracking", "pinned").option("--name <name>", "package alias").option("--select <type/name>", "select an artifact by type/name (repeatable or comma-separated)", collectSelectOption, []).option("--skill <name>", "select a skill by name (repeatable or comma-separated)", collectSkillOption, []).option("--with-suggestions", "include suggested companion artifacts for selected roots on future installs", false).option("--suggestion <alias>", "include one suggested companion alias on future installs (repeatable or comma-separated)", collectSuggestionOption, []).option("--override <source-or-package::type/name>", "allow this package to replace a colliding artifact (repeatable)", collectOverrideOption, []).action(async (source, options) => {
+program.command("add").description("add a package to .agentwheel/config.json without touching runtimes").argument("<source>", "package source").option("--driver <driver>", "source driver (local, git, skillkit, vercel-skills, mcp-registry, or clawhub)").option("--adapter <adapter>", "built-in adapter", "openclaw").option("-i, --installation-type <type>", "installation type (for example local or user)").option("--user", "shortcut for --installation-type user and home-scoped state", false).option("--local", "shortcut for --installation-type local", false).option("--adapter-config <path>", "adapter JSON/JSONC file").option("--adapter-module <path>", "local programmatic adapter module").option("--allow-adapter-code", "allow loading local adapter code", false).option("-t, --target-root <path>", "workspace root").option("--mode <mode>", "pinned or tracking", "pinned").option("--version <range>", "root package version policy (exact, ~, ^, or *)").option("--name <name>", "package alias").option("--select <type/name>", "select an artifact by type/name (repeatable or comma-separated)", collectSelectOption, []).option("--skill <name>", "select a skill by name (repeatable or comma-separated)", collectSkillOption, []).option("--with-suggestions", "include suggested companion artifacts for selected roots on future installs", false).option("--suggestion <alias>", "include one suggested companion alias on future installs (repeatable or comma-separated)", collectSuggestionOption, []).option("--override <source-or-package::type/name>", "allow this package to replace a colliding artifact (repeatable)", collectOverrideOption, []).action(async (source, options) => {
   const normalizedOptions = normalizeRuntimeScopeOptions(options);
   const targetRoot = normalizeTargetRoot(normalizedOptions.targetRoot ?? process.cwd());
   const entry = await packageEntryFromSource(source, targetRoot, normalizedOptions);
@@ -10645,17 +11976,59 @@ program.command("list").description("list artifacts exposed by a package source"
   const resolvedInput = await resolvePackageSource(source, targetRoot);
   const selectedArtifacts = selectedArtifactsFromOptionsOrRegistry(options, resolvedInput.registryEntry);
   const driver = getSourceDriver(options.driver ?? inferSourceDriverName(resolvedInput.source));
-  const resolved = await driver.export(await driver.translate(await driver.fetch(await driver.resolve(resolvedInput.source, { cacheRoot: join41(targetRoot, ".agentwheel", "cache") }))));
+  const resolved = await driver.export(await driver.translate(await driver.fetch(await driver.resolve(resolvedInput.source, { cacheRoot: join45(targetRoot, ".agentwheel", "cache") }))));
   const artifacts = filterArtifactsBySelection(await driver.list(resolved), selectedArtifacts);
   for (const artifact of artifacts) {
     console.log(`${artifact.type}	${artifact.name}	${artifact.relativePath}`);
   }
 });
+program.command("search").description("search registry and public catalogue artifacts").argument("<query>", "search query").option("--json", "print the versioned search response as JSON", false).option("--scope <scope>", "search scope: all, registry, enriched, or vercel", "all").option("--type <type>", "artifact type: package, skill, plugin, mcp, or adapter").option("--ecosystem <ecosystem>", "ecosystem: official, openpack, mcp-registry, clawhub, skillkit, or vercel").option("--limit <n>", "maximum number of results (1-100)", "20").option("--include-archived", "include archived catalogue entries", false).option("--refresh", "refresh registry and catalogue caches", false).option("--offline", "use compatible local caches without network access", false).option("-t, --target-root <path>", "workspace root", process.cwd()).action(async (query, options) => {
+  const trimmedQuery = query.trim();
+  if (!trimmedQuery) {
+    throw new Error("Search query must not be empty.");
+  }
+  const scope = parseSearchScope(options.scope);
+  const type = options.type === void 0 ? void 0 : parseSearchType(options.type);
+  const ecosystem = options.ecosystem === void 0 ? void 0 : parseSearchEcosystem(options.ecosystem);
+  const limit = parseSearchLimit(options.limit);
+  if (options.refresh && options.offline) {
+    throw new Error("--refresh cannot be used with --offline.");
+  }
+  const warning = (message) => console.error(message);
+  const targetRoot = normalizeTargetRoot(options.targetRoot);
+  const registryRequest = scope === "all" || scope === "registry" ? new RegistryClient({ workspaceRoot: targetRoot, offline: options.offline, warn: warning }).getIndex({ refresh: options.refresh }) : void 0;
+  const catalogueRequest = scope === "all" || scope === "enriched" || scope === "vercel" ? new CatalogueClient({ offline: options.offline, warn: warning }).getIndex({ refresh: options.refresh }) : void 0;
+  const [registryIndex, catalogueIndex] = await Promise.all([registryRequest, catalogueRequest]);
+  const entries = buildSearchEntries({
+    registry: registryIndex?.entries,
+    enriched: scope === "all" || scope === "enriched" ? catalogueIndex?.enriched : void 0,
+    vercel: scope === "all" || scope === "vercel" ? catalogueIndex?.vercel : void 0
+  });
+  const results = searchEntries(entries, trimmedQuery, {
+    type,
+    ecosystem,
+    limit,
+    includeArchived: options.includeArchived
+  });
+  const loadedIndexes = [registryIndex, catalogueIndex].filter((index) => index !== void 0);
+  const response = {
+    schemaVersion: 1,
+    query: trimmedQuery,
+    scope,
+    fromCache: loadedIndexes.every((index) => index.fromCache),
+    results
+  };
+  if (options.json) {
+    console.log(JSON.stringify(response, null, 2));
+    return;
+  }
+  printSearchResults(trimmedQuery, results);
+});
 program.command("scan").description("scan a package source for validation findings").argument("<source>", "package source").option("--driver <driver>", "source driver").option("-t, --target-root <path>", "workspace root", process.cwd()).action(async (source, options) => {
   const targetRoot = normalizeTargetRoot(options.targetRoot);
   const resolvedInput = await resolvePackageSource(source, targetRoot);
   const driver = getSourceDriver(options.driver ?? inferSourceDriverName(resolvedInput.source));
-  const resolved = await driver.export(await driver.translate(await driver.fetch(await driver.resolve(resolvedInput.source, { cacheRoot: join41(targetRoot, ".agentwheel", "cache") }))));
+  const resolved = await driver.export(await driver.translate(await driver.fetch(await driver.resolve(resolvedInput.source, { cacheRoot: join45(targetRoot, ".agentwheel", "cache") }))));
   const result = await driver.scan(resolved);
   if (result.findings.length === 0) {
     console.log("Scan ok: no findings");
@@ -10666,13 +12039,13 @@ program.command("scan").description("scan a package source for validation findin
   }
   if (!result.ok) process.exitCode = 1;
 });
-program.command("plan").description("preview what install would reconcile without writing").argument("[name-or-source]", "configured package name/source or package source to preview").option("--driver <driver>", "source driver").option("--adapter <adapter>", "built-in adapter or comma-separated adapters").option("-i, --installation-type <type>", "installation type (for example local or user)").option("--user", "shortcut for --installation-type user and home-scoped state", false).option("--local", "shortcut for --installation-type local", false).option("--adapter-config <path>", "adapter JSON/JSONC file").option("--adapter-module <path>", "local programmatic adapter module").option("--allow-adapter-code", "allow loading local adapter code", false).option("-t, --target-root <path>", "runtime/project root").option("--agent <name>", "named agent from merged config").option("--all", "run for every configured agent", false).option("--all-detected", "run for every runtime directory detected in the target root", false).option("--profile <name>", "workspace runtime profile").option("--mode <mode>", "pinned or tracking").option("--select <type/name>", "select an artifact by type/name (repeatable or comma-separated)", collectSelectOption, []).option("--skill <name>", "select a skill by name (repeatable or comma-separated)", collectSkillOption, []).option("--with-suggestions", "include suggested companion artifacts for selected roots", false).option("--suggestion <alias>", "include one suggested companion alias (repeatable or comma-separated)", collectSuggestionOption, []).option("--override <source-or-package::type/name>", "for source previews, allow the source to replace a colliding artifact (repeatable)", collectOverrideOption, []).option("--dry-run", "accepted for symmetry; plan never writes", false).option("--format <fmt>", "output format: human|json|mermaid|html", "human").option("--json", "print the resolved plan as JSON", false).option("--force-drift", "replace drifted managed artifacts during install planning", false).option("--force-conflict", "adopt unmanaged destinations when their content already matches the desired artifact", false).option("--replace-conflict", "replace unmanaged destinations even when their content differs", false).option("--no-deps", "resolve only root sources and ignore requires with a warning").option("--only-source", "with a source argument, exclude configured workspace packages", false).option("--frozen-lock", "resolve strictly from the existing graph lock and cached sources", false).option("--offline", "resolve strictly from graph locks and local caches", false).option("--yes", "trust all new transitive sources", false).option("--trust <pattern>", "pre-approve a transitive source glob (repeatable)", collectTrustOption, []).action(async (source, options) => {
+program.command("plan").description("preview what install would reconcile without writing").argument("[name-or-source]", "configured package name/source or package source to preview").option("--driver <driver>", "source driver").option("--adapter <adapter>", "built-in adapter or comma-separated adapters").option("-i, --installation-type <type>", "installation type (for example local or user)").option("--user", "shortcut for --installation-type user and home-scoped state", false).option("--local", "shortcut for --installation-type local", false).option("--adapter-config <path>", "adapter JSON/JSONC file").option("--adapter-module <path>", "local programmatic adapter module").option("--allow-adapter-code", "allow loading local adapter code", false).option("-t, --target-root <path>", "runtime/project root").option("--agent <name>", "named agent from merged config").option("--all", "run for every configured agent", false).option("--all-detected", "run for every runtime directory detected in the target root", false).option("--profile <name>", "workspace runtime profile").option("--mode <mode>", "pinned or tracking").option("--select <type/name>", "select an artifact by type/name (repeatable or comma-separated)", collectSelectOption, []).option("--skill <name>", "select a skill by name (repeatable or comma-separated)", collectSkillOption, []).option("--with-suggestions", "include suggested companion artifacts for selected roots", false).option("--suggestion <alias>", "include one suggested companion alias (repeatable or comma-separated)", collectSuggestionOption, []).option("--override <source-or-package::type/name>", "for source previews, allow the source to replace a colliding artifact (repeatable)", collectOverrideOption, []).option("--dry-run", "accepted for symmetry; plan never writes", false).option("--format <fmt>", "output format: human|json|mermaid|html", "human").option("--json", "print the resolved plan as JSON", false).option("--force-drift", "replace drifted managed artifacts during install planning", false).option("--force-conflict", "adopt unmanaged destinations when their content already matches the desired artifact", false).option("--replace-conflict", "replace unmanaged destinations even when their content differs", false).option("--no-deps", "resolve only root sources and ignore requires with a warning").option("--only-source", "with a source argument, exclude configured workspace packages", false).option("--frozen-lock", "resolve strictly from the existing graph lock and cached sources", false).option("--offline", "resolve strictly from graph locks and local caches", false).option("--refresh", "refresh available package versions even when the version-index TTL is fresh", false).option("--yes", "trust all new transitive sources", false).option("--trust <pattern>", "pre-approve a transitive source glob (repeatable)", collectTrustOption, []).action(async (source, options) => {
   await runInstallCommand(source, { ...options, dryRun: true }, { apply: false });
 });
-program.command("install").description("install configured packages into runtime targets").argument("[name-or-source]", "configured package name/source or package source to add and install").option("--driver <driver>", "source driver").option("--adapter <adapter>", "built-in adapter or comma-separated adapters").option("-i, --installation-type <type>", "installation type (for example local or user)").option("--user", "shortcut for --installation-type user and home-scoped state", false).option("--local", "shortcut for --installation-type local", false).option("--adapter-config <path>", "adapter JSON/JSONC file").option("--adapter-module <path>", "local programmatic adapter module").option("--allow-adapter-code", "allow loading local adapter code", false).option("-t, --target-root <path>", "runtime/project root").option("--agent <name>", "named agent from merged config").option("--all", "run for every configured agent", false).option("--all-detected", "run for every runtime directory detected in the target root", false).option("--mode <mode>", "pinned or tracking").option("--select <type/name>", "select an artifact by type/name (repeatable or comma-separated)", collectSelectOption, []).option("--skill <name>", "select a skill by name (repeatable or comma-separated)", collectSkillOption, []).option("--with-suggestions", "include suggested companion artifacts for selected roots", false).option("--suggestion <alias>", "include one suggested companion alias (repeatable or comma-separated)", collectSuggestionOption, []).option("--override <source-or-package::type/name>", "when adding a source, allow it to replace a colliding artifact (repeatable)", collectOverrideOption, []).option("--profile <name>", "workspace runtime profile").option("--dry-run", "show plan without writing", false).option("--format <fmt>", "output format: human|json|mermaid|html", "human").option("--json", "print the resolved plan as JSON", false).option("--force-drift", "replace drifted managed artifacts", false).option("--force-conflict", "adopt unmanaged destinations when their content already matches the desired artifact", false).option("--replace-conflict", "replace unmanaged destinations even when their content differs", false).option("--execute-plugins", "execute semantic plugin installs", false).option("--reload-runtimes", "run configured runtime reload commands after executed semantic plugin changes", false).option("--restart-runtimes", "alias for --reload-runtimes", false).option("--no-deps", "resolve only root sources and ignore requires with a warning").option("--only-source", "with a source argument, exclude configured workspace packages", false).option("--frozen-lock", "resolve strictly from the existing graph lock and cached sources", false).option("--offline", "resolve strictly from graph locks and local caches", false).option("--yes", "trust all new transitive sources", false).option("--trust <pattern>", "pre-approve a transitive source glob (repeatable)", collectTrustOption, []).addHelpText("after", "\nScoped install never removes files owned only by other configured packages; run a full install to reconcile those removals.\n").action(async (source, options) => {
+program.command("install").description("install configured packages into runtime targets").argument("[name-or-source]", "configured package name/source or package source to add and install").option("--driver <driver>", "source driver").option("--adapter <adapter>", "built-in adapter or comma-separated adapters").option("-i, --installation-type <type>", "installation type (for example local or user)").option("--user", "shortcut for --installation-type user and home-scoped state", false).option("--local", "shortcut for --installation-type local", false).option("--adapter-config <path>", "adapter JSON/JSONC file").option("--adapter-module <path>", "local programmatic adapter module").option("--allow-adapter-code", "allow loading local adapter code", false).option("-t, --target-root <path>", "runtime/project root").option("--agent <name>", "named agent from merged config").option("--all", "run for every configured agent", false).option("--all-detected", "run for every runtime directory detected in the target root", false).option("--mode <mode>", "pinned or tracking").option("--select <type/name>", "select an artifact by type/name (repeatable or comma-separated)", collectSelectOption, []).option("--skill <name>", "select a skill by name (repeatable or comma-separated)", collectSkillOption, []).option("--with-suggestions", "include suggested companion artifacts for selected roots", false).option("--suggestion <alias>", "include one suggested companion alias (repeatable or comma-separated)", collectSuggestionOption, []).option("--override <source-or-package::type/name>", "when adding a source, allow it to replace a colliding artifact (repeatable)", collectOverrideOption, []).option("--profile <name>", "workspace runtime profile").option("--dry-run", "show plan without writing", false).option("--format <fmt>", "output format: human|json|mermaid|html", "human").option("--json", "print the resolved plan as JSON", false).option("--force-drift", "replace drifted managed artifacts", false).option("--force-conflict", "adopt unmanaged destinations when their content already matches the desired artifact", false).option("--replace-conflict", "replace unmanaged destinations even when their content differs", false).option("--execute-plugins", "execute semantic plugin installs", false).option("--reload-runtimes", "run configured runtime reload commands after executed semantic plugin changes", false).option("--restart-runtimes", "alias for --reload-runtimes", false).option("--no-deps", "resolve only root sources and ignore requires with a warning").option("--only-source", "with a source argument, exclude configured workspace packages", false).option("--frozen-lock", "resolve strictly from the existing graph lock and cached sources", false).option("--offline", "resolve strictly from graph locks and local caches", false).option("--refresh", "refresh available package versions even when the version-index TTL is fresh", false).option("--yes", "trust all new transitive sources", false).option("--trust <pattern>", "pre-approve a transitive source glob (repeatable)", collectTrustOption, []).addHelpText("after", "\nScoped install never removes files owned only by other configured packages; run a full install to reconcile those removals.\n").action(async (source, options) => {
   await runInstallCommand(source, options, { apply: !options.dryRun });
 });
-program.command("serve").description("serve a read-only live dashboard for the resolved install plan").argument("[name-or-source]", "configured package name/source or package source to preview").option("--driver <driver>", "source driver").option("--adapter <adapter>", "built-in adapter or comma-separated adapters").option("-i, --installation-type <type>", "installation type (for example local or user)").option("--user", "shortcut for --installation-type user and home-scoped state", false).option("--local", "shortcut for --installation-type local", false).option("--adapter-config <path>", "adapter JSON/JSONC file").option("--adapter-module <path>", "local programmatic adapter module").option("--allow-adapter-code", "allow loading local adapter code", false).option("-t, --target-root <path>", "runtime/project root").option("--agent <name>", "named agent from merged config").option("--all", "run for every configured agent", false).option("--all-detected", "run for every runtime directory detected in the target root", false).option("--profile <name>", "workspace runtime profile").option("--mode <mode>", "pinned or tracking").option("--select <type/name>", "select an artifact by type/name (repeatable or comma-separated)", collectSelectOption, []).option("--skill <name>", "select a skill by name (repeatable or comma-separated)", collectSkillOption, []).option("--with-suggestions", "include suggested companion artifacts for selected roots", false).option("--suggestion <alias>", "include one suggested companion alias (repeatable or comma-separated)", collectSuggestionOption, []).option("--override <source-or-package::type/name>", "for source previews, allow the source to replace a colliding artifact (repeatable)", collectOverrideOption, []).option("--force-drift", "replace drifted managed artifacts during install planning", false).option("--force-conflict", "adopt unmanaged destinations when their content already matches the desired artifact", false).option("--replace-conflict", "replace unmanaged destinations even when their content differs", false).option("--no-deps", "resolve only root sources and ignore requires with a warning").option("--only-source", "with a source argument, exclude configured workspace packages", false).option("--frozen-lock", "resolve strictly from the existing graph lock and cached sources", false).option("--offline", "resolve strictly from graph locks and local caches", false).option("--yes", "trust all new transitive sources", false).option("--trust <pattern>", "pre-approve a transitive source glob (repeatable)", collectTrustOption, []).option("--bind <addr>", "interface to bind", "127.0.0.1").option("--port <n>", "TCP port (0 selects an ephemeral port)", "8765").option("--interval <seconds>", "background re-render cadence in seconds", "60").option("--once", "render once and skip the background re-render loop", false).action(async (source, options) => {
+program.command("serve").description("serve a read-only live dashboard for the resolved install plan").argument("[name-or-source]", "configured package name/source or package source to preview").option("--driver <driver>", "source driver").option("--adapter <adapter>", "built-in adapter or comma-separated adapters").option("-i, --installation-type <type>", "installation type (for example local or user)").option("--user", "shortcut for --installation-type user and home-scoped state", false).option("--local", "shortcut for --installation-type local", false).option("--adapter-config <path>", "adapter JSON/JSONC file").option("--adapter-module <path>", "local programmatic adapter module").option("--allow-adapter-code", "allow loading local adapter code", false).option("-t, --target-root <path>", "runtime/project root").option("--agent <name>", "named agent from merged config").option("--all", "run for every configured agent", false).option("--all-detected", "run for every runtime directory detected in the target root", false).option("--profile <name>", "workspace runtime profile").option("--mode <mode>", "pinned or tracking").option("--select <type/name>", "select an artifact by type/name (repeatable or comma-separated)", collectSelectOption, []).option("--skill <name>", "select a skill by name (repeatable or comma-separated)", collectSkillOption, []).option("--with-suggestions", "include suggested companion artifacts for selected roots", false).option("--suggestion <alias>", "include one suggested companion alias (repeatable or comma-separated)", collectSuggestionOption, []).option("--override <source-or-package::type/name>", "for source previews, allow the source to replace a colliding artifact (repeatable)", collectOverrideOption, []).option("--force-drift", "replace drifted managed artifacts during install planning", false).option("--force-conflict", "adopt unmanaged destinations when their content already matches the desired artifact", false).option("--replace-conflict", "replace unmanaged destinations even when their content differs", false).option("--no-deps", "resolve only root sources and ignore requires with a warning").option("--only-source", "with a source argument, exclude configured workspace packages", false).option("--frozen-lock", "resolve strictly from the existing graph lock and cached sources", false).option("--offline", "resolve strictly from graph locks and local caches", false).option("--refresh", "refresh available package versions even when the version-index TTL is fresh", false).option("--yes", "trust all new transitive sources", false).option("--trust <pattern>", "pre-approve a transitive source glob (repeatable)", collectTrustOption, []).option("--bind <addr>", "interface to bind", "127.0.0.1").option("--port <n>", "TCP port (0 selects an ephemeral port)", "8765").option("--interval <seconds>", "background re-render cadence in seconds", "60").option("--once", "render once and skip the background re-render loop", false).action(async (source, options) => {
   await servePlanDashboard({
     bind: options.bind,
     port: parseServePort(options.port),
@@ -10681,11 +12054,11 @@ program.command("serve").description("serve a read-only live dashboard for the r
     buildReport: () => buildPlanReport(source, options)
   });
 });
-program.command("sync", { hidden: true }).argument("[name-or-source]", "configured package name/source or package source").option("--driver <driver>", "source driver").option("--adapter <adapter>", "built-in adapter or comma-separated adapters").option("-i, --installation-type <type>", "installation type (for example local or user)").option("--user", "shortcut for --installation-type user and home-scoped state", false).option("--local", "shortcut for --installation-type local", false).option("--adapter-config <path>", "adapter JSON/JSONC file").option("--adapter-module <path>", "local programmatic adapter module").option("--allow-adapter-code", "allow loading local adapter code", false).option("-t, --target-root <path>", "runtime/project root").option("--agent <name>", "named agent from merged config").option("--all", "run for every configured agent", false).option("--all-detected", "run for every runtime directory detected in the target root", false).option("--mode <mode>", "pinned or tracking").option("--select <type/name>", "select an artifact by type/name (repeatable or comma-separated)", collectSelectOption, []).option("--skill <name>", "select a skill by name (repeatable or comma-separated)", collectSkillOption, []).option("--with-suggestions", "include suggested companion artifacts for selected roots", false).option("--suggestion <alias>", "include one suggested companion alias (repeatable or comma-separated)", collectSuggestionOption, []).option("--override <source-or-package::type/name>", "when adding a source, allow it to replace a colliding artifact (repeatable)", collectOverrideOption, []).option("--profile <name>", "workspace runtime profile").option("--dry-run", "show plan without writing", false).option("--force-drift", "replace drifted managed artifacts", false).option("--force-conflict", "adopt unmanaged destinations when their content already matches the desired artifact", false).option("--replace-conflict", "replace unmanaged destinations even when their content differs", false).option("--execute-plugins", "execute semantic plugin installs", false).option("--reload-runtimes", "run configured runtime reload commands after executed semantic plugin changes", false).option("--restart-runtimes", "alias for --reload-runtimes", false).option("--no-deps", "resolve only root sources and ignore requires with a warning").option("--only-source", "with a source argument, exclude configured workspace packages", false).option("--frozen-lock", "resolve strictly from the existing graph lock and cached sources", false).option("--offline", "resolve strictly from graph locks and local caches", false).option("--yes", "trust all new transitive sources", false).option("--trust <pattern>", "pre-approve a transitive source glob (repeatable)", collectTrustOption, []).action(async (source, options) => {
+program.command("sync", { hidden: true }).argument("[name-or-source]", "configured package name/source or package source").option("--driver <driver>", "source driver").option("--adapter <adapter>", "built-in adapter or comma-separated adapters").option("-i, --installation-type <type>", "installation type (for example local or user)").option("--user", "shortcut for --installation-type user and home-scoped state", false).option("--local", "shortcut for --installation-type local", false).option("--adapter-config <path>", "adapter JSON/JSONC file").option("--adapter-module <path>", "local programmatic adapter module").option("--allow-adapter-code", "allow loading local adapter code", false).option("-t, --target-root <path>", "runtime/project root").option("--agent <name>", "named agent from merged config").option("--all", "run for every configured agent", false).option("--all-detected", "run for every runtime directory detected in the target root", false).option("--mode <mode>", "pinned or tracking").option("--select <type/name>", "select an artifact by type/name (repeatable or comma-separated)", collectSelectOption, []).option("--skill <name>", "select a skill by name (repeatable or comma-separated)", collectSkillOption, []).option("--with-suggestions", "include suggested companion artifacts for selected roots", false).option("--suggestion <alias>", "include one suggested companion alias (repeatable or comma-separated)", collectSuggestionOption, []).option("--override <source-or-package::type/name>", "when adding a source, allow it to replace a colliding artifact (repeatable)", collectOverrideOption, []).option("--profile <name>", "workspace runtime profile").option("--dry-run", "show plan without writing", false).option("--force-drift", "replace drifted managed artifacts", false).option("--force-conflict", "adopt unmanaged destinations when their content already matches the desired artifact", false).option("--replace-conflict", "replace unmanaged destinations even when their content differs", false).option("--execute-plugins", "execute semantic plugin installs", false).option("--reload-runtimes", "run configured runtime reload commands after executed semantic plugin changes", false).option("--restart-runtimes", "alias for --reload-runtimes", false).option("--no-deps", "resolve only root sources and ignore requires with a warning").option("--only-source", "with a source argument, exclude configured workspace packages", false).option("--frozen-lock", "resolve strictly from the existing graph lock and cached sources", false).option("--offline", "resolve strictly from graph locks and local caches", false).option("--refresh", "refresh available package versions even when the version-index TTL is fresh", false).option("--yes", "trust all new transitive sources", false).option("--trust <pattern>", "pre-approve a transitive source glob (repeatable)", collectTrustOption, []).action(async (source, options) => {
   console.error("warning: 'agentwheel sync' is deprecated and will be removed in 0.10. Use 'agentwheel install'.");
   await runInstallCommand(source, options, { apply: !options.dryRun });
 });
-program.command("update").description("re-resolve tracking packages, then apply the result").argument("[name]", "configured package name or source to update").option("--adapter <adapter>", "built-in adapter or comma-separated adapters").option("-i, --installation-type <type>", "installation type (for example local or user)").option("--user", "shortcut for --installation-type user and home-scoped state", false).option("--local", "shortcut for --installation-type local", false).option("-t, --target-root <path>", "workspace root").option("--agent <name>", "named agent from merged config").option("--all", "run for every configured agent", false).option("--profile <name>", "workspace runtime profile").option("--dry-run", "show plans without writing", false).option("--force-drift", "replace drifted managed artifacts", false).option("--force-conflict", "adopt unmanaged destinations when their content already matches the desired artifact", false).option("--replace-conflict", "replace unmanaged destinations even when their content differs", false).option("--execute-plugins", "execute semantic plugin installs", false).option("--reload-runtimes", "run configured runtime reload commands after executed semantic plugin changes", false).option("--restart-runtimes", "alias for --reload-runtimes", false).option("--allow-adapter-code", "allow loading local adapter code from configured packages", false).option("--select <type/name>", "temporarily select an artifact by type/name (repeatable or comma-separated)", collectSelectOption, []).option("--skill <name>", "temporarily select a skill by name (repeatable or comma-separated)", collectSkillOption, []).option("--dependency <name-or-source>", "update one tracking dependency while keeping unrelated graph nodes locked (repeatable)", collectDependencyOption, []).option("--with-suggestions", "include suggested companion artifacts for selected roots", false).option("--suggestion <alias>", "include one suggested companion alias (repeatable or comma-separated)", collectSuggestionOption, []).option("--no-deps", "resolve only root sources and ignore requires with a warning").option("--frozen-lock", "resolve strictly from the existing graph lock and cached sources", false).option("--offline", "resolve strictly from graph locks and local caches", false).option("--yes", "trust all new transitive sources", false).option("--trust <pattern>", "pre-approve a transitive source glob (repeatable)", collectTrustOption, []).action(async (name, options) => {
+program.command("update").description("re-resolve tracking packages, then apply the result").argument("[name]", "configured package name or source to update").option("--adapter <adapter>", "built-in adapter or comma-separated adapters").option("-i, --installation-type <type>", "installation type (for example local or user)").option("--user", "shortcut for --installation-type user and home-scoped state", false).option("--local", "shortcut for --installation-type local", false).option("-t, --target-root <path>", "workspace root").option("--agent <name>", "named agent from merged config").option("--all", "run for every configured agent", false).option("--profile <name>", "workspace runtime profile").option("--dry-run", "show plans without writing", false).option("--force-drift", "replace drifted managed artifacts", false).option("--force-conflict", "adopt unmanaged destinations when their content already matches the desired artifact", false).option("--replace-conflict", "replace unmanaged destinations even when their content differs", false).option("--execute-plugins", "execute semantic plugin installs", false).option("--reload-runtimes", "run configured runtime reload commands after executed semantic plugin changes", false).option("--restart-runtimes", "alias for --reload-runtimes", false).option("--allow-adapter-code", "allow loading local adapter code from configured packages", false).option("--select <type/name>", "temporarily select an artifact by type/name (repeatable or comma-separated)", collectSelectOption, []).option("--skill <name>", "temporarily select a skill by name (repeatable or comma-separated)", collectSkillOption, []).option("--dependency <name-or-source>", "update one tracking dependency while keeping unrelated graph nodes locked (repeatable)", collectDependencyOption, []).option("--with-suggestions", "include suggested companion artifacts for selected roots", false).option("--suggestion <alias>", "include one suggested companion alias (repeatable or comma-separated)", collectSuggestionOption, []).option("--no-deps", "resolve only root sources and ignore requires with a warning").option("--frozen-lock", "resolve strictly from the existing graph lock and cached sources", false).option("--offline", "resolve strictly from graph locks and local caches", false).option("--refresh", "refresh available package versions even when the version-index TTL is fresh", false).option("--yes", "trust all new transitive sources", false).option("--trust <pattern>", "pre-approve a transitive source glob (repeatable)", collectTrustOption, []).action(async (name, options) => {
   if (name && options.dependency.length > 0) throw new Error("A package argument cannot be combined with --dependency.");
   if (options.dependency.length > 0 && (options.select.length > 0 || options.skill.length > 0)) {
     throw new Error("--dependency cannot be combined with --select or --skill; package selections remain unchanged.");
@@ -10694,6 +12067,11 @@ program.command("update").description("re-resolve tracking packages, then apply
     throw new Error("--dependency cannot be combined with --frozen-lock or --offline.");
   }
   const normalizedOptions = normalizeRuntimeScopeOptions(options);
+  const composite = await resolveSelectedCompositeProfile(normalizedOptions);
+  if (composite) {
+    await runCompositeUpdate(composite.workspaceRoot, composite.name, composite.profile, name, normalizedOptions);
+    return;
+  }
   const targets = await resolveCliTargets(normalizedOptions, { preferAllProfile: true });
   for (const target of targets) {
     await runConfiguredGraphPackages(target, { ...normalizedOptions, scope: name }, { mode: "update" });
@@ -10713,7 +12091,7 @@ program.command("deps").description("inspect the OpenPack dependency graph").add
           for (const decision of result.bundle.graphLock.canonical.overrides) {
             console.log(`OVERRIDE ${decision.graphNodeId}:${decision.type}/${decision.name} replaces ${decision.overriddenGraphNodeId}:${decision.type}/${decision.name} via ${decision.rootId} (${decision.selector})`);
           }
-          await rm11(result.bundle.root, { recursive: true, force: true });
+          await rm12(result.bundle.root, { recursive: true, force: true });
         }
         continue;
       }
@@ -10745,11 +12123,6 @@ program.command("registry").description("manage optional registry indexes").addC
     const client = new RegistryClient({ workspaceRoot: normalizeTargetRoot(options.targetRoot), warn: (message) => console.warn(message) });
     printRegistryEntries((await client.getIndex()).entries);
   })
-).addCommand(
-  new Command("search").description("search registry entries").argument("<query>", "search query").option("-t, --target-root <path>", "workspace root", process.cwd()).action(async (query, options) => {
-    const client = new RegistryClient({ workspaceRoot: normalizeTargetRoot(options.targetRoot), warn: (message) => console.warn(message) });
-    printRegistryEntries(await client.search(query));
-  })
 ).addCommand(
   new Command("publish").description("draft a catalogue submission for a public source").argument("<source>", "public resource source or GitHub URL").option("--name <name>", "registry short name").option("--type <type>", "entry type (package, skill, plugin, mcp, or adapter)").option("--description <text>", "short catalogue description").option("--tag <tag>", "search tag (repeatable or comma-separated)", collectTagOption, []).option("--select <type/name>", "selected artifact inside a larger package (repeatable or comma-separated)", collectSelectOption, []).option("--skill <name>", "selected skill inside a larger package (repeatable or comma-separated)", collectSkillOption, []).option("--json", "print only the registry entry JSON", false).action(async (source, options) => {
     const draft = createRegistryPublishDraft(source, {
@@ -10889,9 +12262,25 @@ program.command("uninstall").description("remove configured packages or managed
     if (plan.hasBlockingChanges) process.exitCode = 1;
   }
 });
-program.command("status").description("show configured packages and runtime install state").option("--adapter <adapter>", "built-in adapter or comma-separated adapters").option("-i, --installation-type <type>", "installation type (for example local or user)").option("--user", "shortcut for --installation-type user and home-scoped state", false).option("--local", "shortcut for --installation-type local", false).option("--adapter-config <path>", "adapter JSON/JSONC file").option("--adapter-module <path>", "local programmatic adapter module").option("--allow-adapter-code", "allow loading local adapter code", false).option("-t, --target-root <path>", "runtime/project root").option("--agent <name>", "named agent from merged config").option("--all", "run for every configured agent", false).option("--profile <name>", "workspace runtime profile").action(async (options) => {
+program.command("status").description("show configured packages and runtime install state").option("--adapter <adapter>", "built-in adapter or comma-separated adapters").option("-i, --installation-type <type>", "installation type (for example local or user)").option("--user", "shortcut for --installation-type user and home-scoped state", false).option("--local", "shortcut for --installation-type local", false).option("--adapter-config <path>", "adapter JSON/JSONC file").option("--adapter-module <path>", "local programmatic adapter module").option("--allow-adapter-code", "allow loading local adapter code", false).option("-t, --target-root <path>", "runtime/project root").option("--agent <name>", "named agent from merged config").option("--all", "run for every configured agent", false).option("--profile <name>", "workspace runtime profile").option("--json", "print the versioned status protocol as JSON", false).option("--offline", "use cached version and member status even when stale", false).option("--refresh", "refresh package and member status regardless of TTL", false).action(async (options) => {
   const normalizedOptions = normalizeRuntimeScopeOptions(options);
+  const composite = await resolveSelectedCompositeProfile(normalizedOptions);
+  if (composite) {
+    const report = await collectCompositeStatus(composite.workspaceRoot, composite.name, composite.profile, normalizedOptions);
+    if (options.json) console.log(JSON.stringify(report, null, 2));
+    else printStatusReport(report);
+    if (!["PASS", "WARN"].includes(report.health)) process.exitCode = 1;
+    return;
+  }
   const targets = await resolveCliTargets(normalizedOptions, { preferAllProfile: true });
+  if (options.json) {
+    const targetReports = [];
+    for (const target of targets) targetReports.push(await collectTargetStatus(target, normalizedOptions));
+    const report = await statusReport(targets[0]?.workspaceRoot ?? process.cwd(), options.profile ?? null, targetReports);
+    console.log(JSON.stringify(report, null, 2));
+    if (!["PASS", "WARN"].includes(report.health)) process.exitCode = 1;
+    return;
+  }
   for (const target of targets) {
     await printStatus(target, normalizedOptions);
   }
@@ -10907,7 +12296,7 @@ journalCommand.command("list").description("show pending apply journals for reso
     if (!journal) continue;
     pending += 1;
     console.log(`PENDING ${state.adapter.name}/${state.installationType} at ${state.installRoot}`);
-    console.log(`  journal: ${join41(state.installRoot, ".agentwheel", `${state.state.stateKey}.apply-journal.json`)}`);
+    console.log(`  journal: ${join45(state.installRoot, ".agentwheel", `${state.state.stateKey}.apply-journal.json`)}`);
     console.log(`  stateKey: ${state.state.stateKey}`);
     console.log(`  createdAt: ${journal.createdAt}`);
     console.log(`  updatedAt: ${journal.updatedAt}`);
@@ -10941,6 +12330,21 @@ program.command("doctor").description("check agentwheel runtime setup and compan
 async function runInstallCommand(nameOrSource, options, behavior) {
   const normalizedOptions = normalizeRuntimeScopeOptions(options, { defaultUser: shouldDefaultUserInstall(nameOrSource, options) });
   const outputFormat = effectivePlanOutputFormat(normalizedOptions);
+  const composite = await resolveSelectedCompositeProfile(normalizedOptions);
+  if (composite) {
+    if (outputFormat !== "human") {
+      throw new Error("Composite profile plan/install currently requires human output; use status --json for the versioned member protocol.");
+    }
+    await runCompositeInstall(
+      composite.workspaceRoot,
+      composite.name,
+      composite.profile,
+      nameOrSource,
+      normalizedOptions,
+      behavior
+    );
+    return;
+  }
   if (outputFormat !== "human") {
     const report = await buildPlanReport(nameOrSource, normalizedOptions);
     if (report.targets.some((target) => target.hasBlockingChanges)) process.exitCode = 1;
@@ -11032,7 +12436,7 @@ async function runInstallCommand(nameOrSource, options, behavior) {
         console.log(`Applied ${result.plan.adapter} at ${result.plan.targetRoot}.`);
         if (reloaded) console.log(`Reloaded runtime via ${formatReloadCommands(target.reloadCommands)}.`);
       }
-      await rm11(result.bundle.root, { recursive: true, force: true });
+      await rm12(result.bundle.root, { recursive: true, force: true });
       if (result.plan.hasBlockingChanges) process.exitCode = 1;
     }
     if (behavior.apply && extraPackage && !targetOptions.onlySource) {
@@ -11127,7 +12531,7 @@ async function buildPlanReport(nameOrSource, options) {
     for (const result of results) {
       reportTargets.push(installPlanReportTarget(result.plan, result.graphLockDigest));
       reportWarnings.push(...result.warnings);
-      await rm11(result.bundle.root, { recursive: true, force: true });
+      await rm12(result.bundle.root, { recursive: true, force: true });
     }
   }
   return planReport(reportTargets, reportWarnings);
@@ -11160,11 +12564,32 @@ async function packageEntryFromSource(source, targetRoot, options) {
     baseDir: targetRoot,
     warn: options.warn ?? ((message) => console.warn(message))
   });
+  const provisionalName = options.name ?? resolvedInput.registryEntry?.name ?? source;
+  const initialVersion = options.mode === "tracking" && options.version ? await effectiveTrackingRef({
+    name: provisionalName,
+    source: resolvedSource,
+    driver: driverName,
+    adapter: adapter.name,
+    installationType: options.installationType,
+    mode: "tracking",
+    version: options.version
+  }, targetRoot, { offline: options.offline }) : void 0;
+  if (initialVersion?.availability?.error || initialVersion?.availability?.stale) {
+    throw new Error(
+      `Cannot select an initial version for ${provisionalName}: ${initialVersion.availability?.error ?? "version metadata is stale"}`
+    );
+  }
+  if (initialVersion?.availability && !initialVersion.availability.latestAllowedRef) {
+    throw new Error(
+      `No available version of ${provisionalName} satisfies ${options.version}; latest overall is ${initialVersion.availability.latestOverall ?? "unknown"}.`
+    );
+  }
   const bundle = await stageSource(driver, resolvedSource, {
     workspaceRoot: targetRoot,
     adapter,
-    cacheRoot: join41(targetRoot, ".agentwheel", "cache"),
+    cacheRoot: join45(targetRoot, ".agentwheel", "cache"),
     mode: options.mode,
+    ref: initialVersion?.ref,
     frozenLock: lockMode,
     select: selectedArtifacts
   });
@@ -11180,6 +12605,7 @@ async function packageEntryFromSource(source, targetRoot, options) {
       adapterModule: options.adapterModule,
       adapterCodeHash: adapter.programmatic?.hash,
       mode: options.mode ?? "pinned",
+      version: options.version,
       requestedRef: bundle.source.requestedRef,
       select: selectedArtifacts,
       withSuggestions: options.withSuggestions === true ? true : void 0,
@@ -11187,7 +12613,7 @@ async function packageEntryFromSource(source, targetRoot, options) {
       overrides: overrideArtifactsFromOptions(options)
     };
   } finally {
-    await rm11(bundle.root, { recursive: true, force: true });
+    await rm12(bundle.root, { recursive: true, force: true });
   }
 }
 function findConfiguredPackage(packages, value) {
@@ -11338,7 +12764,7 @@ async function runConfiguredGraphPackages(target, options, behavior) {
       console.log(`Applied ${result.plan.adapter} at ${result.plan.targetRoot}.`);
       if (reloaded) console.log(`Reloaded runtime via ${formatReloadCommands(target.reloadCommands)}.`);
     }
-    await rm11(result.bundle.root, { recursive: true, force: true });
+    await rm12(result.bundle.root, { recursive: true, force: true });
     if (result.plan.hasBlockingChanges) process.exitCode = 1;
   }
 }
@@ -11396,28 +12822,61 @@ async function buildGraphPlansForTarget(target, source, options, behavior) {
     const allPackages = [...group.packages, ...group.extraPackages];
     const groupHasScope = !scopedRootId || allPackages.some((pkg) => pkg.name === scopedRootId || pkg.source === targetOptions.scope);
     if (behavior.mode === "install" && scopedRootId && !groupHasScope) continue;
+    const groupGraphLockPath = graphLockPathForTarget(
+      group.target.workspaceRoot,
+      targetKeyForTarget(group.target, adapter.name),
+      adapter.name,
+      targetFingerprintParts(group.target, adapter, group.adapterOptions, group.installationType)
+    );
+    const previousGroupLock = await (await pathExists(groupGraphLockPath) ? readGraphLock(groupGraphLockPath) : void 0);
     const dependencyUpdateRootNames = /* @__PURE__ */ new Set();
     if (scopedDependencyUpdate) {
-      const graphLockPath = graphLockPathForTarget(
-        group.target.workspaceRoot,
-        targetKeyForTarget(group.target, adapter.name),
-        adapter.name,
-        targetFingerprintParts(group.target, adapter, group.adapterOptions, group.installationType)
-      );
-      const previousLock = await (await pathExists(graphLockPath) ? readGraphLock(graphLockPath) : void 0);
       for (const pkg of group.packages) {
-        const root = previousLock?.canonical.roots.find((candidate) => candidate.rootId === pkg.name);
+        const root = previousGroupLock?.canonical.roots.find((candidate) => candidate.rootId === pkg.name);
         if (root?.mode !== "tracking") continue;
-        const node = previousLock?.canonical.nodes.find((candidate) => candidate.id === root.graphNodeId);
+        const node = previousGroupLock?.canonical.nodes.find((candidate) => candidate.id === root.graphNodeId);
         if (node && dependencyUpdateSelectors.some((selector) => dependencyUpdateSelectorMatchesRoot(root, node, selector))) {
           dependencyUpdateRootNames.add(pkg.name);
         }
       }
     }
     const updateScope = behavior.mode === "update" ? scopedPackage ? /* @__PURE__ */ new Set([scopedPackage.name]) : void 0 : void 0;
+    const versionSelections = /* @__PURE__ */ new Map();
+    const lockedVersionRefs = /* @__PURE__ */ new Map();
+    const versionPolicyUpdateNames = /* @__PURE__ */ new Set();
+    for (const pkg of allPackages) {
+      if (pkg.mode !== "tracking" || !pkg.version) continue;
+      const previousRoot = previousGroupLock?.canonical.roots.find((candidate) => candidate.rootId === pkg.name);
+      const previousNode = previousRoot ? previousGroupLock?.canonical.nodes.find((candidate) => candidate.id === previousRoot.graphNodeId) : void 0;
+      const policyRequiresResolution = !previousNode || !satisfiesVersionRange(previousNode.version, pkg.version);
+      if (!policyRequiresResolution && previousNode?.requestedRef) {
+        lockedVersionRefs.set(pkg.name, previousNode.requestedRef);
+      }
+      const packageUpdateSelected = !updateScope || updateScope.has(pkg.name);
+      if (behavior.mode === "update" && packageUpdateSelected || behavior.mode === "install" && policyRequiresResolution) {
+        const selection = await effectiveTrackingRef(pkg, group.target.workspaceRoot, {
+          offline: targetOptions.offline,
+          forceRefresh: targetOptions.refresh
+        });
+        if (selection.availability?.error || selection.availability?.stale) {
+          throw new Error(
+            `Cannot resolve ${pkg.name} with stale version metadata: ${selection.availability?.error ?? "version index TTL expired"}`
+          );
+        }
+        versionSelections.set(pkg.name, selection);
+        if (policyRequiresResolution) versionPolicyUpdateNames.add(pkg.name);
+        if (!selection.availability?.latestAllowed) {
+          targetOptions.warn?.(
+            `No available version of ${pkg.name} satisfies ${pkg.version}; latest overall is ${selection.availability?.latestOverall ?? "unknown"}.`
+          );
+        }
+      }
+    }
     const roots = [
       ...allPackages.map((pkg) => {
-        const updateThisPackage = behavior.mode === "update" && !scopedDependencyUpdate && pkg.mode === "tracking" && (!updateScope || updateScope.has(pkg.name) || updateScope.has(pkg.source));
+        const versionSelection = versionSelections.get(pkg.name);
+        const versionAllowsUpdate = !pkg.version || Boolean(versionSelection?.availability?.latestAllowed);
+        const updateThisPackage = behavior.mode === "update" && !scopedDependencyUpdate && pkg.mode === "tracking" && versionAllowsUpdate && (!updateScope || updateScope.has(pkg.name) || updateScope.has(pkg.source));
         const packageIsScoped = scopedRootId ? pkg.name === scopedRootId || pkg.source === targetOptions.scope : true;
         if (pkg.selection && selectedArtifacts && packageIsScoped) {
           throw new Error(`--select/--skill cannot override imported selection for configured package '${pkg.name}'.`);
@@ -11426,14 +12885,15 @@ async function buildGraphPlansForTarget(target, source, options, behavior) {
           rootId: pkg.name,
           source: pkg.source,
           mode: pkg.mode,
-          ref: pkg.requestedRef,
+          version: pkg.version,
+          ref: versionSelection?.ref ?? lockedVersionRefs.get(pkg.name) ?? pkg.requestedRef,
           select: pkg.selection ? void 0 : selectedArtifacts && packageIsScoped ? selectedArtifacts : normalizeArtifactSelectors(pkg.select, pkg.skills),
           selection: pkg.selection,
           aliases: pkg.aliases,
           overrides: pkg.overrides,
           includeSuggestions: targetOptions.withSuggestions === true || pkg.withSuggestions === true,
           suggestionAliases: packageSuggestionAliases(pkg, targetOptions),
-          useLock: behavior.mode === "install" ? true : scopedDependencyUpdate ? !dependencyUpdateRootNames.has(pkg.name) : !updateThisPackage
+          useLock: behavior.mode === "install" ? !versionPolicyUpdateNames.has(pkg.name) : scopedDependencyUpdate ? !dependencyUpdateRootNames.has(pkg.name) : !updateThisPackage
         };
       }),
       ...group.extraRoots
@@ -11474,7 +12934,7 @@ async function buildGraphPlansForTarget(target, source, options, behavior) {
     if ((behavior.mode === "install" || behavior.mode === "update") && scopedRootId) {
       const state = installStateForTarget(group.target, adapter, group.adapterOptions, group.installationType);
       const manifest = await readInstallManifest(state.installRoot, adapter.name, transport, state);
-      results.push(scopeInstallPlanToRoot(result, scopedRootId, manifest));
+      results.push(behavior.mode === "update" && previousGroupLock ? scopeUpdatePlanToRoot(result, scopedRootId, previousGroupLock, manifest) : scopeInstallPlanToRoot(result, scopedRootId, manifest));
     } else if (scopedDependencyUpdate) {
       const state = installStateForTarget(group.target, adapter, group.adapterOptions, group.installationType);
       const manifest = await readInstallManifest(state.installRoot, adapter.name, transport, state);
@@ -11521,7 +12981,7 @@ function scopeUpdatePlanToDependencies(result, selectors, previousLock, manifest
     selectedPreviousNodeIds,
     selectedRootIds
   );
-  const graphLockDigest = createHash11("sha256").update(canonicalGraphLockJson(graphLock)).digest("hex");
+  const graphLockDigest = createHash12("sha256").update(canonicalGraphLockJson(graphLock)).digest("hex");
   return {
     ...result,
     bundle: { ...result.bundle, graphLock },
@@ -11678,6 +13138,44 @@ function scopeInstallPlanToRoot(result, rootId, manifest) {
     }
   };
 }
+function scopeUpdatePlanToRoot(result, rootId, previousLock, manifest) {
+  const scoped = scopeInstallPlanToRoot(result, rootId, manifest);
+  const selectedCurrentNodeIds = graphRootClosure(scoped.bundle.graphLock, rootId);
+  const selectedPreviousNodeIds = graphRootClosure(previousLock, rootId);
+  const graphLock = preserveUnrelatedGraphPackages(
+    scoped.bundle.graphLock,
+    previousLock,
+    selectedCurrentNodeIds,
+    selectedPreviousNodeIds,
+    /* @__PURE__ */ new Set([rootId])
+  );
+  const graphLockDigest = createHash12("sha256").update(canonicalGraphLockJson(graphLock)).digest("hex");
+  return {
+    ...scoped,
+    bundle: { ...scoped.bundle, graphLock },
+    graphLockDigest,
+    graphDiff: diffGraphLocks(previousLock, graphLock),
+    plan: {
+      ...scoped.plan,
+      graphLockDigest
+    }
+  };
+}
+function graphRootClosure(lock, rootId) {
+  const root = lock.canonical.roots.find((candidate) => candidate.rootId === rootId);
+  if (!root) return /* @__PURE__ */ new Set();
+  const selected = /* @__PURE__ */ new Set();
+  const queue = [root.graphNodeId];
+  while (queue.length > 0) {
+    const nodeId = queue.shift();
+    if (selected.has(nodeId)) continue;
+    selected.add(nodeId);
+    for (const edge of lock.canonical.edges) {
+      if (edge.from === nodeId) queue.push(edge.to);
+    }
+  }
+  return selected;
+}
 function transformOutOfScopeOperation(operation, entry, targetRoot, scopeDescription) {
   if (operation.action === "skip") return [operation];
   if (operation.action === "update" || operation.action === "drift") {
@@ -11723,7 +13221,7 @@ function keepManifestEntryOperation(entry, targetRoot, scopeDescription, operati
     artifactType: entry.artifactType,
     artifactName: entry.artifactName,
     kind: entry.kind,
-    destPath: operation?.destPath ?? join41(targetRoot, entry.path),
+    destPath: operation?.destPath ?? join45(targetRoot, entry.path),
     relativeDestPath: entry.path,
     desiredHash: entry.sourceHash,
     currentHash: operation?.currentHash ?? entry.hash,
@@ -11785,6 +13283,7 @@ async function uninstallConfiguredPackage(target, packageName, options) {
           rootId: pkg2.name,
           source: pkg2.source,
           mode: pkg2.mode,
+          version: pkg2.version,
           ref: pkg2.requestedRef,
           select: pkg2.selection ? void 0 : normalizeArtifactSelectors(pkg2.select, pkg2.skills),
           selection: pkg2.selection,
@@ -11839,7 +13338,7 @@ async function uninstallConfiguredPackage(target, packageName, options) {
     if (!options.dryRun) {
       console.log(formatUninstallResult(result));
     }
-    if (renderedRoot) await rm11(renderedRoot, { recursive: true, force: true });
+    if (renderedRoot) await rm12(renderedRoot, { recursive: true, force: true });
     if (plan.hasBlockingChanges) process.exitCode = 1;
   }
 }
@@ -11921,31 +13420,341 @@ async function readTargetGraphLock(target, options) {
   return { adapter, path, lock: await readGraphLock(path) };
 }
 async function printStatus(target, options) {
+  const report = await collectTargetStatus(target, options);
+  printTargetStatus(report);
+}
+async function collectTargetStatus(target, options) {
   const config = await readMergedWorkspaceConfig(target.workspaceRoot);
   const adapterOptions = adapterOptionsForTarget(target, options);
-  const adapter = await resolveAdapterForTarget(target, adapterOptions);
+  const adapter = await resolveAdapterForTarget(target, { ...adapterOptions, warn: () => void 0 });
   const transport = transportForTarget(target);
   const installationType = options.installationType ?? target.installationType ?? resolveInstallationTypeForAdapter(adapter);
   const state = installStateForTarget(target, adapter, adapterOptions, installationType);
-  console.log(`Status for ${adapter.name}/${installationType} at ${state.installRoot}`);
-  if (config.packages.length === 0) {
-    console.log(`Configured packages: none at ${target.workspaceRoot}`);
-    return;
-  }
-  console.log("Configured packages:");
-  for (const pkg of config.packages) {
-    console.log(`- ${pkg.name} (${pkg.mode}) ${pkg.source}`);
-  }
   const manifest = await readInstallManifest(state.installRoot, adapter.name, transport, state);
-  console.log(manifest ? `Install manifest: ${manifest.entries.length} entries, revision ${manifest.revision}` : "Install manifest: missing");
+  let graphLockPath = null;
+  let graphLock;
   try {
-    const { path, lock } = await readTargetGraphLock(target, adapterOptions);
-    console.log(`Graph lock: ${path}`);
-    console.log(`Locked graph: ${lock.canonical.roots.length} roots, ${lock.canonical.nodes.length} nodes, ${lock.canonical.artifacts.length} artifacts`);
+    const result = await readTargetGraphLock(target, adapterOptions);
+    graphLockPath = result.path;
+    graphLock = result.lock;
   } catch {
-    console.log("Graph lock: missing");
+    graphLock = void 0;
+  }
+  const packages = [];
+  for (const pkg of config.packages) {
+    const root = graphLock?.canonical.roots.find((candidate) => candidate.rootId === pkg.name);
+    const node = root ? graphLock?.canonical.nodes.find((candidate) => candidate.id === root.graphNodeId) : void 0;
+    const availability = await discoverPackageVersions(pkg, target.workspaceRoot, {
+      forceRefresh: options.refresh,
+      offline: options.offline
+    });
+    const installed = node && manifest?.entries.some((entry) => "graphNodeId" in entry && entry.graphNodeId === node.id) ? node.version : null;
+    const locked = node?.version ?? null;
+    const baseline = installed ?? locked;
+    packages.push({
+      name: pkg.name,
+      source: pkg.source,
+      mode: pkg.mode,
+      policy: pkg.version ?? "*",
+      installed,
+      locked,
+      latestAllowed: availability.latestAllowed,
+      latestOverall: availability.latestOverall,
+      availability: availability.stale ? "STALE" : availability.checkedAt ? "FRESH" : "UNKNOWN",
+      checkedAt: availability.checkedAt,
+      ...availability.error ? { error: availability.error } : {},
+      updateAvailableAllowed: Boolean(
+        baseline && availability.latestAllowed && compareSemverStrings(availability.latestAllowed, baseline) > 0
+      ),
+      updateAvailableOverall: Boolean(
+        baseline && availability.latestOverall && compareSemverStrings(availability.latestOverall, baseline) > 0
+      )
+    });
   }
-  await printPendingInstallWork(target, options);
+  const pending = await collectPendingInstallWork(target, options);
+  const artifacts = (graphLock?.canonical.artifacts ?? []).map((artifact) => {
+    const node = graphLock?.canonical.nodes.find((candidate) => candidate.id === artifact.graphNodeId);
+    const installed = manifest?.entries.some((entry) => {
+      if (!("graphNodeId" in entry) || entry.graphNodeId !== artifact.graphNodeId) return false;
+      if ("logicalSelector" in entry && entry.logicalSelector) return entry.logicalSelector === artifact.logicalSelector;
+      return entry.artifactType === artifact.type && entry.artifactName === artifact.name;
+    }) ?? false;
+    return {
+      selector: artifact.logicalSelector,
+      type: artifact.type,
+      name: artifact.name,
+      installName: artifact.installName,
+      packageName: node?.name ?? null,
+      packageVersion: node?.version ?? null,
+      hash: artifact.hash,
+      installed
+    };
+  });
+  const health = [];
+  if (!manifest || !graphLock) health.push("FAIL");
+  if (pending.error) health.push("DEGRADED");
+  if (pending.driftCount > 0 || pending.conflictCount > 0) health.push("FAIL");
+  else if (pending.pendingCount > 0) health.push("WARN");
+  if (packages.some((pkg) => pkg.availability === "STALE" || pkg.error)) health.push("DEGRADED");
+  else if (packages.some((pkg) => pkg.updateAvailableAllowed || pkg.updateAvailableOverall)) health.push("WARN");
+  return {
+    adapter: adapter.name,
+    installationType,
+    targetRoot: state.installRoot,
+    health: worstStatusHealth(health),
+    manifestRevision: manifest?.revision ?? null,
+    manifestEntryCount: manifest?.entries.length ?? 0,
+    graphLockPath,
+    packageCount: packages.length,
+    artifactCount: graphLock?.canonical.artifacts.length ?? 0,
+    pendingCount: pending.pendingCount,
+    driftCount: pending.driftCount,
+    conflictCount: pending.conflictCount,
+    ...pending.error ? { error: pending.error } : {},
+    packages,
+    artifacts
+  };
+}
+async function resolveSelectedCompositeProfile(options) {
+  const workspaceRoot = await findWorkspaceRoot(options.targetRoot ?? process.cwd());
+  const config = await readMergedWorkspaceConfig(workspaceRoot);
+  const name = options.profile ?? (options.all && config.profiles.all ? "all" : void 0);
+  if (!name) return void 0;
+  const profile = config.profiles[name];
+  if (!profile) throw new Error(`Unknown profile: ${name}`);
+  if (!isCompositeWorkspaceProfile(profile)) return void 0;
+  const chain = parseCompositeChain();
+  assertNoCompositeCycle(workspaceRoot, name, chain);
+  return { workspaceRoot, name, profile };
+}
+async function collectCompositeStatus(workspaceRoot, profileName, profile, options) {
+  const chain = parseCompositeChain();
+  const members = await collectCompositeMembers({
+    cliVersion: CLI_VERSION,
+    workspaceRoot,
+    profileName,
+    profileTtlSeconds: profile.refreshTtlSeconds,
+    members: profile.members,
+    refresh: options.refresh,
+    offline: options.offline,
+    chain
+  });
+  const repository = await collectRepositoryStatus(workspaceRoot);
+  const repositoryHealth = repository.available && repository.ahead === 0 && repository.behind === 0 && repository.dirtyCount === 0 ? "PASS" : "WARN";
+  return {
+    schemaVersion: 1,
+    command: "status",
+    agentwheelVersion: CLI_VERSION,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    workspace: workspaceRoot,
+    profile: profileName,
+    health: worstStatusHealth([...members.map((member) => member.health), repositoryHealth]),
+    repository,
+    targets: [],
+    members
+  };
+}
+async function runCompositeUpdate(workspaceRoot, profileName, profile, packageName, options) {
+  const preflight = await collectCompositeStatus(workspaceRoot, profileName, profile, options);
+  printStatusReport(preflight);
+  const blockers = preflight.members.filter((member) => blocksCompositeApply(member.health));
+  if (blockers.length > 0) {
+    throw new Error(
+      `Composite update blocked before member execution: ` + blockers.map((member) => `${member.id}=${member.health}`).join(", ")
+    );
+  }
+  const incomingChain = parseCompositeChain();
+  const memberChain = [...incomingChain, compositeKey(workspaceRoot, profileName)];
+  for (const member of profile.members) {
+    if (!options.dryRun) {
+      const before = preflight.members.find((candidate) => candidate.id === member.id);
+      const revalidated = await collectCompositeMembers({
+        cliVersion: CLI_VERSION,
+        workspaceRoot,
+        profileName,
+        profileTtlSeconds: profile.refreshTtlSeconds,
+        members: [member],
+        refresh: true,
+        chain: incomingChain
+      });
+      const current = revalidated[0];
+      if (blocksCompositeApply(current.health)) {
+        throw new Error(`Composite update stopped before ${member.id}: revalidation is ${current.health}.`);
+      }
+      if (statusRevisionSignature(before?.report) !== statusRevisionSignature(current.report)) {
+        throw new Error(`Composite update stopped before ${member.id}: member revision changed after preflight.`);
+      }
+    }
+    const args = compositeUpdateArguments(member.profile, packageName, options);
+    console.log(`${options.dryRun ? "Plan" : "Update"} member ${member.id}:`);
+    const result = await runMemberAgentwheel(member, workspaceRoot, args, memberChain);
+    if (result.stdout.trim()) console.log(result.stdout.trimEnd());
+    if (result.stderr.trim()) console.error(result.stderr.trimEnd());
+  }
+}
+async function runCompositeInstall(workspaceRoot, profileName, profile, nameOrSource, options, behavior) {
+  const preflight = await collectCompositeStatus(workspaceRoot, profileName, profile, options);
+  printStatusReport(preflight);
+  const blockers = preflight.members.filter((member) => blocksCompositeApply(member.health));
+  if (blockers.length > 0) {
+    throw new Error(
+      `Composite ${behavior.apply ? "install" : "plan"} blocked before member execution: ` + blockers.map((member) => `${member.id}=${member.health}`).join(", ")
+    );
+  }
+  const incomingChain = parseCompositeChain();
+  const memberChain = [...incomingChain, compositeKey(workspaceRoot, profileName)];
+  for (const member of profile.members) {
+    if (behavior.apply) {
+      const before = preflight.members.find((candidate) => candidate.id === member.id);
+      const revalidated = await collectCompositeMembers({
+        cliVersion: CLI_VERSION,
+        workspaceRoot,
+        profileName,
+        profileTtlSeconds: profile.refreshTtlSeconds,
+        members: [member],
+        refresh: true,
+        chain: incomingChain
+      });
+      const current = revalidated[0];
+      if (blocksCompositeApply(current.health)) {
+        throw new Error(`Composite install stopped before ${member.id}: revalidation is ${current.health}.`);
+      }
+      if (statusRevisionSignature(before?.report) !== statusRevisionSignature(current.report)) {
+        throw new Error(`Composite install stopped before ${member.id}: member revision changed after preflight.`);
+      }
+    }
+    const args = compositeInstallArguments(member.profile, nameOrSource, options, behavior.apply);
+    console.log(`${behavior.apply ? "Install" : "Plan"} member ${member.id}:`);
+    const result = await runMemberAgentwheel(member, workspaceRoot, args, memberChain);
+    if (result.stdout.trim()) console.log(result.stdout.trimEnd());
+    if (result.stderr.trim()) console.error(result.stderr.trimEnd());
+  }
+}
+function compositeInstallArguments(profile, nameOrSource, options, apply) {
+  const args = [apply ? "install" : "plan"];
+  if (nameOrSource) args.push(nameOrSource);
+  args.push("--profile", profile);
+  if (options.refresh) args.push("--refresh");
+  if (options.forceDrift) args.push("--force-drift");
+  if (options.forceConflict) args.push("--force-conflict");
+  if (options.replaceConflict) args.push("--replace-conflict");
+  if (options.executePlugins) args.push("--execute-plugins");
+  if (shouldReloadRuntimes(options)) args.push("--reload-runtimes");
+  if (options.noDeps) args.push("--no-deps");
+  if (options.frozenLock) args.push("--frozen-lock");
+  if (options.onlySource) args.push("--only-source");
+  for (const selection of options.select ?? []) args.push("--select", selection);
+  for (const skill of options.skill ?? []) args.push("--skill", skill);
+  for (const trust of options.trust ?? []) args.push("--trust", trust);
+  if (options.yes) args.push("--yes");
+  return args;
+}
+function compositeUpdateArguments(profile, packageName, options) {
+  const args = ["update"];
+  if (packageName) args.push(packageName);
+  args.push("--profile", profile);
+  if (options.dryRun) args.push("--dry-run");
+  if (options.refresh) args.push("--refresh");
+  if (options.forceDrift) args.push("--force-drift");
+  if (options.forceConflict) args.push("--force-conflict");
+  if (options.replaceConflict) args.push("--replace-conflict");
+  if (options.executePlugins) args.push("--execute-plugins");
+  if (shouldReloadRuntimes(options)) args.push("--reload-runtimes");
+  if (options.noDeps) args.push("--no-deps");
+  if (options.frozenLock) args.push("--frozen-lock");
+  for (const dependency of options.dependency ?? []) args.push("--dependency", dependency);
+  for (const trust of options.trust ?? []) args.push("--trust", trust);
+  if (options.yes) args.push("--yes");
+  return args;
+}
+function statusRevisionSignature(report) {
+  if (!report) return "missing";
+  return JSON.stringify({
+    profile: report.profile,
+    repository: {
+      head: report.repository.head,
+      ahead: report.repository.ahead,
+      behind: report.repository.behind,
+      dirtyCount: report.repository.dirtyCount
+    },
+    targets: report.targets.map((target) => ({
+      adapter: target.adapter,
+      installationType: target.installationType,
+      targetRoot: target.targetRoot,
+      manifestRevision: target.manifestRevision,
+      graphLockPath: target.graphLockPath,
+      packages: target.packages.map((pkg) => ({
+        name: pkg.name,
+        installed: pkg.installed,
+        locked: pkg.locked,
+        latestAllowed: pkg.latestAllowed,
+        latestOverall: pkg.latestOverall
+      }))
+    })),
+    members: report.members.map((member) => ({
+      id: member.id,
+      report: statusRevisionSignature(member.report)
+    }))
+  });
+}
+async function statusReport(workspace, profile, targets) {
+  const repository = await collectRepositoryStatus(workspace);
+  const repositoryHealth = repository.available && repository.ahead === 0 && repository.behind === 0 && repository.dirtyCount === 0 ? "PASS" : "WARN";
+  return {
+    schemaVersion: 1,
+    command: "status",
+    agentwheelVersion: CLI_VERSION,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    workspace,
+    profile,
+    health: worstStatusHealth([...targets.map((target) => target.health), repositoryHealth]),
+    repository,
+    targets,
+    members: []
+  };
+}
+function printStatusReport(report) {
+  console.log(`Status ${report.health} for profile ${report.profile ?? "(direct)"} at ${report.workspace}`);
+  console.log(
+    `Repository: ${report.repository.available ? report.repository.branch ?? "detached" : "unavailable"}; ahead=${report.repository.ahead}; behind=${report.repository.behind}; dirty=${report.repository.dirtyCount}`
+  );
+  if (report.members.length > 0) {
+    console.log("MEMBER	TRANSPORT	PROFILE	VERSION	HEALTH	CACHE");
+    for (const member of report.members) {
+      console.log([
+        member.id,
+        member.transport,
+        member.profile,
+        member.agentwheelVersion ?? "unknown",
+        member.health,
+        member.stale ? "stale" : "fresh"
+      ].join("	"));
+      if (member.error) console.log(`  ${member.error}`);
+    }
+  }
+  for (const target of report.targets) printTargetStatus(target);
+}
+function printTargetStatus(target) {
+  console.log(`Status for ${target.adapter}/${target.installationType} at ${target.targetRoot} (health: ${target.health})`);
+  console.log(target.manifestRevision ? `Install manifest: ${target.manifestEntryCount} entries, revision ${target.manifestRevision}` : "Install manifest: missing");
+  console.log(target.graphLockPath ? `Graph lock: ${target.graphLockPath} (${target.artifactCount} artifacts)` : "Graph lock: missing");
+  console.log("PACKAGE	MODE	POLICY	INSTALLED	LOCKED	LATEST ALLOWED	LATEST OVERALL	STATUS");
+  for (const pkg of target.packages) {
+    console.log([
+      pkg.name,
+      pkg.mode,
+      pkg.policy,
+      pkg.installed ?? "-",
+      pkg.locked ?? "-",
+      pkg.latestAllowed ?? "-",
+      pkg.latestOverall ?? "-",
+      pkg.availability
+    ].join("	"));
+  }
+  console.log(`Artifacts: ${target.artifactCount} locked, ${target.artifacts.filter((artifact) => artifact.installed).length} installed`);
+  if (target.error) console.log(`Pending install work: unavailable (${target.error})`);
+  else if (target.pendingCount === 0) console.log("Pending install work: none");
+  else console.log(`Pending install work: ${target.pendingCount} (drift=${target.driftCount}, conflict=${target.conflictCount})`);
 }
 async function journalStateForTarget(target, options) {
   const adapterOptions = adapterOptionsForTarget(target, options);
@@ -11955,27 +13764,32 @@ async function journalStateForTarget(target, options) {
   const state = installStateForTarget(target, adapter, adapterOptions, installationType);
   return { adapter, transport, installationType, installRoot: state.installRoot, state };
 }
-async function printPendingInstallWork(target, options) {
+async function collectPendingInstallWork(target, options) {
   let results = [];
   try {
-    results = await buildGraphPlansForTarget(target, void 0, { ...options, dryRun: true }, { mode: "install" });
+    results = await buildGraphPlansForTarget(
+      target,
+      void 0,
+      { ...options, dryRun: true, warn: options.warn ?? (() => void 0) },
+      { mode: "install" }
+    );
     const operations = results.flatMap((result) => result.plan.operations);
     const pending = operations.filter(isPendingInstallOperation);
-    if (pending.length === 0) {
-      console.log("Pending install work: none");
-      return;
-    }
-    const counts = [...pending.reduce((map, operation) => {
+    const counts = Object.fromEntries([...pending.reduce((map, operation) => {
       map.set(operation.action, (map.get(operation.action) ?? 0) + 1);
       return map;
-    }, /* @__PURE__ */ new Map())].map(([action, count]) => `${action}=${count}`).join(", ");
-    const blocking = pending.filter((operation) => operation.action === "conflict" || operation.action === "drift").length;
-    console.log(`Pending install work: ${pending.length} operations (${counts}${blocking ? `; blocking=${blocking}` : ""})`);
+    }, /* @__PURE__ */ new Map())]);
+    return {
+      pendingCount: pending.length,
+      driftCount: counts.drift ?? 0,
+      conflictCount: counts.conflict ?? 0,
+      counts
+    };
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    console.log(`Pending install work: unavailable (${message})`);
+    return { pendingCount: 0, driftCount: 0, conflictCount: 0, counts: {}, error: message };
   } finally {
-    await Promise.all(results.map((result) => rm11(result.bundle.root, { recursive: true, force: true })));
+    await Promise.all(results.map((result) => rm12(result.bundle.root, { recursive: true, force: true })));
   }
 }
 async function printDoctor(target, options) {
@@ -11992,12 +13806,12 @@ async function printDoctor(target, options) {
   const requestedSkills = doctorSkillRequests(target, options);
   const skills = [];
   for (const request of requestedSkills) {
-    const skillPath = join41(state.installRoot, targetMapping.dest, request.name);
+    const skillPath = join45(state.installRoot, targetMapping.dest, request.name);
     const exists = await pathExists(skillPath);
     const manifestEntry = manifest?.entries.find((entry) => {
       if (entry.artifactType !== "skills") return false;
       const legacyInstallName = "installName" in entry && typeof entry.installName === "string" ? entry.installName : void 0;
-      return entry.artifactName === request.name || legacyInstallName === request.name || entry.path === join41(targetMapping.dest, request.name);
+      return entry.artifactName === request.name || legacyInstallName === request.name || entry.path === join45(targetMapping.dest, request.name);
     });
     const status = manifestEntry ? "managed" : exists ? "present-unmanaged" : "missing";
     skills.push({
@@ -12077,7 +13891,7 @@ function doctorSkillLabel(name) {
   return `${name} skill`;
 }
 function isSyncwheelWorkspace(targetRoot) {
-  return existsSync(join41(targetRoot, ".syncwheel", "manifest.json"));
+  return existsSync(join45(targetRoot, ".syncwheel", "manifest.json"));
 }
 function skillInstallCommand(adapter, installationType, options, skill, behavior = {}) {
   const args = [
@@ -12145,7 +13959,7 @@ function normalizeRuntimeScopeOptions(options, behavior = {}) {
   }
   const canDefaultTargetRoot = !options.agent && !options.all && !options.allDetected && !options.profile;
   if (!targetRoot && canDefaultTargetRoot && (options.user || installationType === "user" || behavior.defaultUser)) {
-    targetRoot = homedir9();
+    targetRoot = homedir10();
   }
   if (!installationType && behavior.defaultUser) {
     installationType = "user";
@@ -12165,12 +13979,12 @@ function looksLikeSourceSpecifier(value) {
   return value.includes(":") || value.startsWith("/") || value.startsWith("./") || value.startsWith("../") || value === "~" || value.startsWith("~/");
 }
 function normalizeCliPath(value) {
-  if (value === "~") return homedir9();
-  if (value.startsWith("~/")) return resolve20(homedir9(), value.slice(2));
-  return resolve20(value);
+  if (value === "~") return homedir10();
+  if (value.startsWith("~/")) return resolve22(homedir10(), value.slice(2));
+  return resolve22(value);
 }
 function isHomePath(path) {
-  return resolve20(path) === resolve20(homedir9());
+  return resolve22(path) === resolve22(homedir10());
 }
 function adapterListFromOption(adapter) {
   if (!adapter) return [];
@@ -12225,10 +14039,10 @@ function filterUninstallPlanBySelection(plan, selected) {
   };
 }
 async function initPackage(root) {
-  await mkdir22(join41(root, "instructions"), { recursive: true });
-  await mkdir22(join41(root, "rules"), { recursive: true });
-  await mkdir22(join41(root, "skills"), { recursive: true });
-  const manifestPath = join41(root, "openpack.json");
+  await mkdir23(join45(root, "instructions"), { recursive: true });
+  await mkdir23(join45(root, "rules"), { recursive: true });
+  await mkdir23(join45(root, "skills"), { recursive: true });
+  const manifestPath = join45(root, "openpack.json");
   const manifest = {
     schemaVersion: 2,
     name: "example/agentwheel-package",
@@ -12239,12 +14053,12 @@ async function initPackage(root) {
       { type: "skills", path: "skills" }
     ]
   };
-  await writeFile21(manifestPath, `${JSON.stringify(manifest, null, 2)}
+  await writeFile22(manifestPath, `${JSON.stringify(manifest, null, 2)}
 `, "utf8");
-  await writeFile21(join41(root, "instructions", "AGENTS.md"), "# Agent Instructions\n", "utf8");
+  await writeFile22(join45(root, "instructions", "AGENTS.md"), "# Agent Instructions\n", "utf8");
 }
 async function defaultBootstrapPackage(_root) {
-  const packageRoot = await findAgentwheelPackageRoot(dirname31(fileURLToPath3(import.meta.url)));
+  const packageRoot = await findAgentwheelPackageRoot(dirname32(fileURLToPath3(import.meta.url)));
   if (!packageRoot) return void 0;
   return {
     name: "agentwheel",
@@ -12288,10 +14102,10 @@ function withFleetExample(config) {
   };
 }
 async function findAgentwheelPackageRoot(start) {
-  let current = resolve20(start);
+  let current = resolve22(start);
   while (true) {
     if (await findPackageManifestPath(current, { warnLegacy: false })) return current;
-    const parent = dirname31(current);
+    const parent = dirname32(current);
     if (parent === current) return void 0;
     current = parent;
   }
@@ -12312,6 +14126,49 @@ function printRegistryEntries(entries) {
     console.log(`${entry.name}	${entry.type}	${entry.source}	${entry.description}${tags}`);
   }
 }
+function parseSearchScope(value) {
+  const parsed = searchScopeSchema.safeParse(value);
+  if (parsed.success) return parsed.data;
+  throw new Error(`Invalid search scope: ${value}. Expected one of: ${searchScopeSchema.options.join(", ")}.`);
+}
+function parseSearchType(value) {
+  const parsed = searchTypeSchema.safeParse(value);
+  if (parsed.success) return parsed.data;
+  throw new Error(`Invalid artifact type: ${value}. Expected one of: ${searchTypeSchema.options.join(", ")}.`);
+}
+function parseSearchEcosystem(value) {
+  const parsed = searchEcosystemSchema.safeParse(value);
+  if (parsed.success) return parsed.data;
+  throw new Error(`Invalid ecosystem: ${value}. Expected one of: ${searchEcosystemSchema.options.join(", ")}.`);
+}
+function parseSearchLimit(value) {
+  const limit = Number(value);
+  if (!Number.isInteger(limit) || limit < 1 || limit > 100) {
+    throw new Error(`Invalid search limit: ${value}. Expected an integer from 1 to 100.`);
+  }
+  return limit;
+}
+function printSearchResults(query, results) {
+  if (results.length === 0) {
+    console.log(`No artifacts found for ${JSON.stringify(query)}.`);
+    return;
+  }
+  for (const [index, result] of results.entries()) {
+    const ecosystem = result.ecosystem ?? "unknown";
+    const provenances = result.provenances.join("+");
+    console.log(
+      `${index + 1}. ${result.name} [type=${result.type}; ecosystem=${ecosystem}; installability=${result.installability}; provenance=${provenances}]`
+    );
+    console.log(`   ${result.description || "(no description)"}`);
+    if (result.installCommand) {
+      console.log(`   Install: ${result.installCommand}`);
+    } else if (result.source) {
+      console.log(`   Source: ${result.source}`);
+    } else {
+      console.log("   Install: unavailable");
+    }
+  }
+}
 async function main() {
   await maybeCheckForUpdate({
     currentVersion: CLI_VERSION,