@harness-lab/cli 0.2.8 → 0.3.0

package/src/run-cli.js

@@ -16,6 +16,7 @@ function sleep(ms) {
 function parseArgs(argv) {
   const positionals = [];
   const flags = {};
+  const booleanFlags = new Set(["json", "help", "version", "force", "no-open", "clear"]);
 
   for (let index = 0; index < argv.length; index += 1) {
     const value = argv[index];
@@ -29,6 +30,10 @@ function parseArgs(argv) {
     }
     if (value.startsWith("--")) {
       const key = value.slice(2);
+      if (booleanFlags.has(key)) {
+        flags[key] = true;
+        continue;
+      }
       const next = argv[index + 1];
       if (!next || next.startsWith("--")) {
         flags[key] = true;
@@ -161,12 +166,47 @@ function summarizeWorkshopInstance(instance) {
   };
 }
 
+function summarizeParticipantAccess(participantAccess) {
+  return {
+    instanceId: participantAccess?.instanceId ?? null,
+    active: participantAccess?.active ?? false,
+    version: participantAccess?.version ?? null,
+    codeId: participantAccess?.codeId ?? null,
+    expiresAt: participantAccess?.expiresAt ?? null,
+    canRevealCurrent: participantAccess?.canRevealCurrent ?? false,
+    source: participantAccess?.source ?? "missing",
+    currentCode: participantAccess?.currentCode ?? null,
+  };
+}
+
+function resolveCurrentInstanceTarget(session, env) {
+  if (typeof session?.selectedInstanceId === "string" && session.selectedInstanceId.trim().length > 0) {
+    return {
+      instanceId: session.selectedInstanceId.trim(),
+      source: "session",
+    };
+  }
+
+  if (typeof env?.HARNESS_WORKSHOP_INSTANCE_ID === "string" && env.HARNESS_WORKSHOP_INSTANCE_ID.trim().length > 0) {
+    return {
+      instanceId: env.HARNESS_WORKSHOP_INSTANCE_ID.trim(),
+      source: "env",
+    };
+  }
+
+  return {
+    instanceId: null,
+    source: "none",
+  };
+}
+
 function printUsage(io, ui) {
   ui.heading("Harness CLI");
   ui.paragraph(`Version ${version}`);
   ui.blank();
   ui.section("Usage");
   ui.commandList([
+    "harness [--json] <command>",
     "harness --help",
     "harness --version",
     "harness version",
@@ -178,9 +218,12 @@ function printUsage(io, ui) {
     "harness auth logout",
     "harness auth status",
     "harness skill install [--target PATH] [--force]",
+    "harness workshop current-instance",
+    "harness workshop select-instance <instance-id> [--clear]",
     "harness workshop status",
     "harness workshop list-instances",
     "harness workshop show-instance <instance-id>",
+    "harness workshop participant-access [<instance-id>] [--rotate] [--code VALUE]",
     "harness workshop archive [--notes TEXT]",
     "harness workshop create-instance [<instance-id>] [--template-id ID] [--content-lang cs|en] [--event-title TEXT] [--city CITY]",
     "harness workshop update-instance <instance-id> [--content-lang cs|en] [--event-title TEXT] [--city CITY]",
@@ -563,6 +606,22 @@ async function handleAuthLogout(io, ui, env, deps) {
   return 0;
 }
 
+function renderSelectedInstanceBanner(ui, target) {
+  if (ui.jsonMode) {
+    return;
+  }
+  const instanceId = target.instanceId ?? "none";
+  const label = target.source === "session"
+    ? "Selected instance (locally selected)"
+    : target.instanceId
+      ? `Selected instance (from ${target.source})`
+      : "Selected instance";
+  ui.keyValue(label, instanceId);
+  if (!target.instanceId) {
+    ui.keyValue("", "no instance is currently selected — run `harness workshop select-instance <id>` to pin one");
+  }
+}
+
 async function handleWorkshopStatus(io, ui, env, deps) {
   const session = await requireSession(io, ui, env);
   if (!session) {
@@ -571,9 +630,42 @@ async function handleWorkshopStatus(io, ui, env, deps) {
 
   try {
     const client = createHarnessClient({ fetchFn: deps.fetchFn, session });
+    const target = resolveCurrentInstanceTarget(session, env);
+
+    renderSelectedInstanceBanner(ui, target);
+
+    if (target.source === "session" && target.instanceId) {
+      const [instanceResult, agenda] = await Promise.all([
+        client.getWorkshopInstance(target.instanceId),
+        client.getWorkshopAgenda(target.instanceId),
+      ]);
+      ui.json("Workshop Status", {
+        ok: true,
+        selectedInstance: {
+          instanceId: target.instanceId,
+          source: target.source,
+          selected: true,
+        },
+        targetInstanceId: target.instanceId,
+        targetSource: target.source,
+        ...summarizeWorkshopInstance(instanceResult.instance),
+        workshopMeta: instanceResult.instance?.workshopMeta ?? null,
+        currentPhase: agenda.phase,
+        agendaItems: Array.isArray(agenda.items) ? agenda.items.length : null,
+      });
+      return 0;
+    }
+
     const [workshop, agenda] = await Promise.all([client.getWorkshopStatus(), client.getAgenda()]);
     ui.json("Workshop Status", {
       ok: true,
+      selectedInstance: {
+        instanceId: target.instanceId ?? null,
+        source: target.source,
+        selected: Boolean(target.instanceId),
+      },
+      targetInstanceId: target.instanceId,
+      targetSource: target.source,
       workshopId: workshop.workshopId,
       workshopMeta: workshop.workshopMeta,
       currentPhase: agenda.phase,
@@ -589,6 +681,107 @@ async function handleWorkshopStatus(io, ui, env, deps) {
   }
 }
 
+async function handleWorkshopCurrentInstance(io, ui, env, deps) {
+  const session = await requireSession(io, ui, env);
+  if (!session) {
+    return 1;
+  }
+
+  const target = resolveCurrentInstanceTarget(session, env);
+  if (!target.instanceId) {
+    ui.json("Workshop Current Instance", {
+      ok: true,
+      instanceId: null,
+      source: target.source,
+      selectedInstanceId: session.selectedInstanceId ?? null,
+    });
+    return 0;
+  }
+
+  try {
+    const client = createHarnessClient({ fetchFn: deps.fetchFn, session });
+    const result = await client.getWorkshopInstance(target.instanceId);
+    ui.json("Workshop Current Instance", {
+      ok: true,
+      source: target.source,
+      selectedInstanceId: session.selectedInstanceId ?? null,
+      ...summarizeWorkshopInstance(result.instance),
+      instance: result.instance,
+    });
+    return 0;
+  } catch (error) {
+    if (error instanceof HarnessApiError) {
+      ui.status("error", `Current instance lookup failed: ${error.message}`, { stream: "stderr" });
+      return 1;
+    }
+    throw error;
+  }
+}
+
+async function handleWorkshopSelectInstance(io, ui, env, positionals, flags, deps) {
+  const session = await requireSession(io, ui, env);
+  if (!session) {
+    return 1;
+  }
+
+  if (flags.clear === true) {
+    const nextSession = { ...session };
+    delete nextSession.selectedInstanceId;
+    if (!(await persistSession(io, ui, env, nextSession))) {
+      return 1;
+    }
+
+    const target = resolveCurrentInstanceTarget(nextSession, env);
+    ui.json("Workshop Select Instance", {
+      ok: true,
+      selectedInstanceId: null,
+      currentInstanceId: target.instanceId,
+      source: target.source,
+      cleared: true,
+    });
+    return 0;
+  }
+
+  const instanceId = await readRequiredCommandValue(
+    io,
+    flags,
+    ["id", "instance-id"],
+    "Instance id: ",
+    readOptionalPositional(positionals, 2),
+  );
+  if (!instanceId) {
+    ui.status("error", "Instance id is required.", { stream: "stderr" });
+    return 1;
+  }
+
+  try {
+    const client = createHarnessClient({ fetchFn: deps.fetchFn, session });
+    const result = await client.getWorkshopInstance(instanceId);
+    const nextSession = {
+      ...session,
+      selectedInstanceId: result.instance?.id ?? instanceId,
+    };
+    if (!(await persistSession(io, ui, env, nextSession))) {
+      return 1;
+    }
+
+    ui.json("Workshop Select Instance", {
+      ok: true,
+      source: "session",
+      selectedInstanceId: nextSession.selectedInstanceId,
+      ...summarizeWorkshopInstance(result.instance),
+      instance: result.instance,
+    });
+    return 0;
+  } catch (error) {
+    if (error instanceof HarnessApiError) {
+      ui.status("error", `Select instance failed: ${error.message}`, { stream: "stderr" });
+      return 1;
+    }
+    throw error;
+  }
+}
+
 async function handleWorkshopListInstances(io, ui, env, deps) {
   const session = await requireSession(io, ui, env);
   if (!session) {
@@ -625,7 +818,7 @@ async function handleWorkshopShowInstance(io, ui, env, positionals, flags, deps)
     flags,
     ["id", "instance-id"],
     "Instance id: ",
-    readOptionalPositional(positionals, 2),
+    readOptionalPositional(positionals, 2) ?? session.selectedInstanceId,
   );
   if (!instanceId) {
     ui.status("error", "Instance id is required.", { stream: "stderr" });
@@ -650,6 +843,55 @@ async function handleWorkshopShowInstance(io, ui, env, positionals, flags, deps)
   }
 }
 
+async function handleWorkshopParticipantAccess(io, ui, env, positionals, flags, deps) {
+  const session = await requireSession(io, ui, env);
+  if (!session) {
+    return 1;
+  }
+
+  const instanceId = await readRequiredCommandValue(
+    io,
+    flags,
+    ["id", "instance-id"],
+    "Instance id: ",
+    readOptionalPositional(positionals, 2) ?? session.selectedInstanceId,
+  );
+  if (!instanceId) {
+    ui.status("error", "Instance id is required.", { stream: "stderr" });
+    return 1;
+  }
+
+  try {
+    const client = createHarnessClient({ fetchFn: deps.fetchFn, session });
+    if (flags.rotate === true) {
+      const result = await client.issueWorkshopParticipantAccess(instanceId, {
+        ...(typeof flags.code === "string" ? { code: flags.code } : {}),
+      });
+      ui.json("Workshop Participant Access", {
+        ok: true,
+        issuedCode: result.issuedCode ?? null,
+        ...summarizeParticipantAccess(result.participantAccess),
+        participantAccess: result.participantAccess,
+      });
+      return 0;
+    }
+
+    const result = await client.getWorkshopParticipantAccess(instanceId);
+    ui.json("Workshop Participant Access", {
+      ok: true,
+      ...summarizeParticipantAccess(result.participantAccess),
+      participantAccess: result.participantAccess,
+    });
+    return 0;
+  } catch (error) {
+    if (error instanceof HarnessApiError) {
+      ui.status("error", `Participant access failed: ${error.message}`, { stream: "stderr" });
+      return 1;
+    }
+    throw error;
+  }
+}
+
 async function handleWorkshopArchive(io, ui, env, flags, deps) {
   const session = await requireSession(io, ui, env);
   if (!session) {
@@ -724,7 +966,7 @@ async function handleWorkshopUpdateInstance(io, ui, env, positionals, flags, dep
     flags,
     ["id"],
     "Instance id: ",
-    readOptionalPositional(positionals, 2),
+    readOptionalPositional(positionals, 2) ?? session.selectedInstanceId,
   );
   if (!instanceId) {
     ui.status("error", "Instance id is required.", { stream: "stderr" });
@@ -739,7 +981,7 @@ async function handleWorkshopUpdateInstance(io, ui, env, positionals, flags, dep
   if (!hasWorkshopMetadataInput(payload)) {
     ui.status(
       "error",
-      "At least one metadata field is required. Use flags such as --event-title, --date-range, --venue-name, or --room-name.",
+      "At least one metadata field is required. Use flags such as --content-lang, --event-title, --date-range, --venue-name, or --room-name.",
       { stream: "stderr" },
     );
     return 1;
@@ -774,7 +1016,7 @@ async function handleWorkshopPrepare(io, ui, env, positionals, flags, deps) {
     flags,
     ["id", "instance-id"],
     "Instance id: ",
-    readOptionalPositional(positionals, 2),
+    readOptionalPositional(positionals, 2) ?? session.selectedInstanceId,
   );
   if (!instanceId) {
     ui.status("error", "Instance id is required.", { stream: "stderr" });
@@ -810,7 +1052,7 @@ async function handleWorkshopResetInstance(io, ui, env, positionals, flags, deps
     flags,
     ["id", "instance-id"],
     "Instance id: ",
-    readOptionalPositional(positionals, 2),
+    readOptionalPositional(positionals, 2) ?? session.selectedInstanceId,
   );
   if (!instanceId) {
     ui.status("error", "Instance id is required.", { stream: "stderr" });
@@ -845,7 +1087,7 @@ async function handleWorkshopRemoveInstance(io, ui, env, positionals, flags, dep
     flags,
     ["id", "instance-id"],
     "Instance id: ",
-    readOptionalPositional(positionals, 2),
+    readOptionalPositional(positionals, 2) ?? session.selectedInstanceId,
   );
   if (!instanceId) {
     ui.status("error", "Instance id is required.", { stream: "stderr" });
@@ -884,7 +1126,11 @@ async function handleWorkshopPhaseSet(io, ui, env, positionals, deps) {
 
   try {
     const client = createHarnessClient({ fetchFn: deps.fetchFn, session });
-    const result = await client.setCurrentPhase(phaseId);
+    const target = resolveCurrentInstanceTarget(session, env);
+    const result =
+      target.source === "session" && target.instanceId
+        ? await client.setCurrentPhaseForInstance(target.instanceId, phaseId)
+        : await client.setCurrentPhase(phaseId);
     ui.json("Workshop Phase", result);
     return 0;
   } catch (error) {
@@ -899,8 +1145,8 @@ async function handleWorkshopPhaseSet(io, ui, env, positionals, deps) {
 export async function runCli(argv, io, deps = {}) {
   const fetchFn = deps.fetchFn ?? globalThis.fetch;
   const mergedDeps = { fetchFn, sleepFn: deps.sleepFn, openUrl: deps.openUrl, cwd: deps.cwd };
-  const ui = createCliUi(io);
   const { positionals, flags } = parseArgs(argv);
+  const ui = createCliUi(io, { jsonMode: flags.json === true || flags.output === "json" });
   const [scope, action, subaction] = positionals;
 
   if (flags.help === true) {
@@ -943,6 +1189,14 @@ export async function runCli(argv, io, deps = {}) {
     return handleSkillInstall(io, ui, mergedDeps, flags);
   }
 
+  if (scope === "workshop" && action === "current-instance") {
+    return handleWorkshopCurrentInstance(io, ui, io.env, mergedDeps);
+  }
+
+  if (scope === "workshop" && action === "select-instance") {
+    return handleWorkshopSelectInstance(io, ui, io.env, positionals, flags, mergedDeps);
+  }
+
   if (scope === "workshop" && action === "status") {
     return handleWorkshopStatus(io, ui, io.env, mergedDeps);
   }
@@ -955,6 +1209,10 @@ export async function runCli(argv, io, deps = {}) {
     return handleWorkshopShowInstance(io, ui, io.env, positionals, flags, mergedDeps);
   }
 
+  if (scope === "workshop" && action === "participant-access") {
+    return handleWorkshopParticipantAccess(io, ui, io.env, positionals, flags, mergedDeps);
+  }
+
   if (scope === "workshop" && action === "archive") {
     return handleWorkshopArchive(io, ui, io.env, flags, mergedDeps);
   }

package/src/session-store.js

@@ -314,6 +314,7 @@ export function sanitizeSession(session, env) {
     authType: session.authType,
     username: session.username ?? null,
     email: session.email ?? null,
+    selectedInstanceId: session.selectedInstanceId ?? null,
     loggedInAt: session.loggedInAt,
     expiresAt: session.expiresAt ?? null,
     mode: session.mode ?? "local-dev",

package/src/skill-install.js

@@ -1,5 +1,6 @@
 import fs from "node:fs/promises";
 import path from "node:path";
+import process from "node:process";
 import {
   createWorkshopBundleManifestFromDirectory,
   createWorkshopBundleManifestFromSource,
@@ -12,6 +13,8 @@ import {
   WORKSHOP_SKILL_NAME,
 } from "./workshop-bundle.js";
 
+const MIN_NODE_MAJOR = 22;
+
 export class SkillInstallError extends Error {
   constructor(message, options = {}) {
     super(message);
@@ -20,6 +23,81 @@ export class SkillInstallError extends Error {
   }
 }
 
+function assertSupportedNodeVersion() {
+  const raw = process.versions?.node;
+  if (!raw) {
+    return;
+  }
+  const major = Number.parseInt(raw.split(".")[0], 10);
+  if (Number.isFinite(major) && major < MIN_NODE_MAJOR) {
+    throw new SkillInstallError(
+      `Harness CLI requires Node.js ${MIN_NODE_MAJOR} or newer. This process is running Node.js ${raw}. Upgrade with your version manager (for example \`nvm install --lts\`) and re-run \`harness skill install\`.`,
+      { code: "unsupported_node_version" },
+    );
+  }
+}
+
+function translateFileSystemError(error, context) {
+  if (!error || typeof error !== "object" || !("code" in error)) {
+    return null;
+  }
+
+  const targetPath = error.path ? ` (${error.path})` : "";
+
+  if (error.code === "EACCES" || error.code === "EPERM") {
+    return new SkillInstallError(
+      `Harness CLI could not ${context}${targetPath} because the current user does not have write permission. Try running from a directory you own, or adjust the directory permissions. On macOS and Linux, that usually means avoiding system paths like /usr. On Windows, avoid running from a protected location such as C:\\Program Files.`,
+      { code: "install_permission_denied" },
+    );
+  }
+
+  if (error.code === "ENOSPC") {
+    return new SkillInstallError(
+      `Harness CLI could not ${context}${targetPath} because the disk is full. Free some space and re-run \`harness skill install\`.`,
+      { code: "install_no_space" },
+    );
+  }
+
+  if (error.code === "ENAMETOOLONG" || error.code === "ENOTDIR") {
+    return new SkillInstallError(
+      `Harness CLI could not ${context}${targetPath}. The target path is too long or part of it is not a directory. On Windows, this often happens when the repository lives in a deeply nested folder — move the repo closer to the drive root (for example C:\\repos\\your-project) and try again.`,
+      { code: "install_path_invalid" },
+    );
+  }
+
+  if (error.code === "EROFS") {
+    return new SkillInstallError(
+      `Harness CLI could not ${context}${targetPath} because the file system is read-only. Re-run \`harness skill install\` from a writable directory.`,
+      { code: "install_read_only" },
+    );
+  }
+
+  if (error.code === "EBUSY") {
+    return new SkillInstallError(
+      `Harness CLI could not ${context}${targetPath} because the target is busy (another process may hold it open). Close editors or agents pointing at \`.agents/skills/\` and re-run \`harness skill install\`.`,
+      { code: "install_target_busy" },
+    );
+  }
+
+  return null;
+}
+
+async function fsWithActionableError(operation, context) {
+  try {
+    return await operation();
+  } catch (error) {
+    if (error instanceof SkillInstallError) {
+      throw error;
+    }
+    const translated = translateFileSystemError(error, context);
+    if (translated) {
+      translated.cause = error;
+      throw translated;
+    }
+    throw error;
+  }
+}
+
 async function resolveBundleSource() {
   const packagedBundlePath = getPackagedWorkshopBundlePath();
   if (await pathExists(path.join(packagedBundlePath, "SKILL.md"))) {
@@ -43,8 +121,14 @@ async function resolveBundleSource() {
 }
 
 async function ensureDirectory(targetPath) {
-  await fs.mkdir(targetPath, { recursive: true });
-  const stat = await fs.stat(targetPath);
+  await fsWithActionableError(
+    () => fs.mkdir(targetPath, { recursive: true }),
+    `create the install target directory`,
+  );
+  const stat = await fsWithActionableError(
+    () => fs.stat(targetPath),
+    `inspect the install target directory`,
+  );
   if (!stat.isDirectory()) {
     throw new SkillInstallError(`Install target is not a directory: ${targetPath}`, {
       code: "invalid_target",
@@ -71,14 +155,22 @@ async function getSourceBundleManifest(resolvedBundle) {
 
 async function installFromResolvedBundle(resolvedBundle, installPath) {
   if (resolvedBundle.mode === "packaged_bundle") {
-    await fs.cp(resolvedBundle.sourcePath, installPath, { recursive: true });
+    await fsWithActionableError(
+      () => fs.cp(resolvedBundle.sourcePath, installPath, { recursive: true }),
+      `copy the workshop bundle into the install target`,
+    );
     return;
   }
 
-  await createWorkshopBundleFromSource(resolvedBundle.sourceRoot, installPath);
+  await fsWithActionableError(
+    () => createWorkshopBundleFromSource(resolvedBundle.sourceRoot, installPath),
+    `build the workshop bundle from source into the install target`,
+  );
 }
 
 export async function installWorkshopSkill(startDir, options = {}) {
+  assertSupportedNodeVersion();
+
   const resolvedBundle = await resolveBundleSource();
   if (!resolvedBundle) {
     throw new SkillInstallError(
@@ -106,7 +198,10 @@ export async function installWorkshopSkill(startDir, options = {}) {
       };
     }
 
-    await fs.rm(installPath, { recursive: true, force: true });
+    await fsWithActionableError(
+      () => fs.rm(installPath, { recursive: true, force: true }),
+      `remove the previous workshop bundle before refreshing it`,
+    );
 
     return {
       ...(await installFreshBundle(resolvedBundle, installPath, targetRoot)),
@@ -115,7 +210,10 @@ export async function installWorkshopSkill(startDir, options = {}) {
   }
 
   if (existingInstall && options.force === true) {
-    await fs.rm(installPath, { recursive: true, force: true });
+    await fsWithActionableError(
+      () => fs.rm(installPath, { recursive: true, force: true }),
+      `remove the previous workshop bundle before reinstalling`,
+    );
   }
 
   const result = await installFreshBundle(resolvedBundle, installPath, targetRoot);
@@ -130,7 +228,10 @@ export async function installWorkshopSkill(startDir, options = {}) {
 }
 
 async function installFreshBundle(resolvedBundle, installPath, targetRoot) {
-  await fs.mkdir(path.dirname(installPath), { recursive: true });
+  await fsWithActionableError(
+    () => fs.mkdir(path.dirname(installPath), { recursive: true }),
+    `create the parent directory for the installed skill`,
+  );
   await installFromResolvedBundle(resolvedBundle, installPath);
 
   return {

package/src/workshop-bundle.js

@@ -26,8 +26,26 @@ const FILE_COPIES = [
   ["docs/locales/en/learner-reference-gallery.md", "docs/locales/en/learner-reference-gallery.md"],
   ["materials/participant-resource-kit.md", "materials/participant-resource-kit.md"],
   ["materials/locales/en/participant-resource-kit.md", "materials/locales/en/participant-resource-kit.md"],
+  ["materials/coaching-codex.md", "materials/coaching-codex.md"],
 ];
 
+// Files that live inside DIRECTORY_COPIES source trees but must not ship to
+// participants. These are author/maintainer/copy-editor artifacts that have no
+// runtime purpose inside the installed workshop skill. Keep the set minimal —
+// every entry should be a file that (a) has no workshop-skill reference and
+// (b) is clearly authoring/governance content rather than participant-facing.
+const EXCLUDED_BUNDLE_PATHS = new Set([
+  "content/style-guide.md",
+  "content/style-examples.md",
+  "content/czech-reject-list.md",
+  "content/czech-editorial-review-checklist.md",
+  "workshop-blueprint/edit-boundaries.md",
+]);
+
+function isExcludedBundlePath(bundleRelativePath) {
+  return EXCLUDED_BUNDLE_PATHS.has(normalizePathForManifest(bundleRelativePath));
+}
+
 export function getPackageRoot() {
   return packageRoot;
 }
@@ -66,24 +84,31 @@ async function copyDirectoryTree(sourceRoot, targetRoot) {
     await copyDirectoryRecursive(
       path.join(sourceRoot, sourceRelativePath),
       path.join(targetRoot, targetRelativePath),
+      targetRelativePath,
     );
   }
 }
 
-async function copyDirectoryRecursive(sourcePath, targetPath) {
+async function copyDirectoryRecursive(sourcePath, targetPath, bundleRelativePrefix) {
   const entries = await fs.readdir(sourcePath, { withFileTypes: true });
   await fs.mkdir(targetPath, { recursive: true });
 
   for (const entry of entries) {
     const sourceEntryPath = path.join(sourcePath, entry.name);
     const targetEntryPath = path.join(targetPath, entry.name);
+    const entryBundleRelativePath = bundleRelativePrefix
+      ? path.join(bundleRelativePrefix, entry.name)
+      : entry.name;
 
     if (entry.isDirectory()) {
-      await copyDirectoryRecursive(sourceEntryPath, targetEntryPath);
+      await copyDirectoryRecursive(sourceEntryPath, targetEntryPath, entryBundleRelativePath);
       continue;
     }
 
     if (entry.isFile()) {
+      if (isExcludedBundlePath(entryBundleRelativePath)) {
+        continue;
+      }
       await fs.copyFile(sourceEntryPath, targetEntryPath);
     }
   }
@@ -187,6 +212,9 @@ export async function createWorkshopBundleManifestFromSource(sourceRoot) {
       if (targetRelative === "workshop-skill/SKILL.md") {
         continue;
       }
+      if (isExcludedBundlePath(targetRelative)) {
+        continue;
+      }
 
       entries.push({
         absolutePath: file.absolutePath,
@@ -225,6 +253,20 @@ async function writeWorkshopBundleManifest(bundleRoot, manifest) {
   );
 }
 
+async function pruneBundleFiles(bundleRoot, manifest) {
+  const expectedFiles = new Set([
+    WORKSHOP_BUNDLE_MANIFEST,
+    ...manifest.files.map((file) => file.path),
+  ]);
+  const currentFiles = await listFilesRecursive(bundleRoot);
+
+  for (const file of currentFiles) {
+    if (!expectedFiles.has(file.relativePath)) {
+      await fs.rm(file.absolutePath, { force: true });
+    }
+  }
+}
+
 export async function createWorkshopBundleFromSource(sourceRoot, targetRoot, options = {}) {
   if (options.clean === true) {
     await fs.rm(targetRoot, { recursive: true, force: true });
@@ -234,6 +276,9 @@ export async function createWorkshopBundleFromSource(sourceRoot, targetRoot, opt
   await fs.rm(path.join(targetRoot, "workshop-skill", "SKILL.md"), { force: true });
   await copyBundleFiles(sourceRoot, targetRoot);
   const manifest = await createWorkshopBundleManifestFromSource(sourceRoot);
+  if (options.prune === true) {
+    await pruneBundleFiles(targetRoot, manifest);
+  }
   await writeWorkshopBundleManifest(targetRoot, manifest);
 }
 
@@ -250,7 +295,7 @@ export async function syncPackagedWorkshopBundle() {
 export async function syncRepoBundledWorkshopSkill() {
   const sourceRoot = getRepoWorkshopSourceRoot();
   const bundleRoot = getRepoBundledWorkshopSkillPath();
-  await createWorkshopBundleFromSource(sourceRoot, bundleRoot, { clean: true });
+  await createWorkshopBundleFromSource(sourceRoot, bundleRoot, { prune: true });
   return {
     sourceRoot,
     bundleRoot,