skillset 0.14.0 → 0.15.1

package/dist/cli.js

@@ -7024,8 +7024,8 @@ var require_dist = __commonJS((exports) => {
 });
 
 // apps/skillset/src/cli-core.ts
-import { mkdir as mkdir11, writeFile as writeFile12 } from "fs/promises";
-import { basename as basename9, dirname as dirname16, resolve as resolve10 } from "path";
+import { mkdir as mkdir12, writeFile as writeFile13 } from "fs/promises";
+import { basename as basename9, dirname as dirname17, resolve as resolve10 } from "path";
 
 // packages/core/src/authoring.ts
 import { readFile as readFile10, writeFile as writeFile4 } from "fs/promises";
@@ -7206,7 +7206,7 @@ var skillsetFeatureRegistry = defineFeatureRegistry([
     id: "output-safety",
     kind: "workflow",
     renderOwner: "packages/core/src/output-safety.ts",
-    sourceShape: "generated .skillset.lock ownership plus current rendered output paths",
+    sourceShape: "generated skillset.lock ownership plus current rendered output paths",
     status: "implemented",
     summary: "Protects unmanaged generated-output collisions and target-side edits with reversible backups.",
     targetSupport: notTargetRuntime(),
@@ -7656,8 +7656,20 @@ var skillsetFeatureRegistry = defineFeatureRegistry([
     validationOwner: "packages/core/src/version-audit.ts"
   }),
   feature({
-    docs: ["docs/features/ci.md", "docs/features/build-scopes.md"],
-    evidence: [test("apps/skillset/src/__tests__/ci.test.ts", "CI and build-scope coverage")],
+    docs: ["docs/features/ci.md", "docs/features/build-scopes.md", "docs/features/workbench.md"],
+    evidence: [
+      test("apps/skillset/src/__tests__/ci.test.ts", "CI and build-scope coverage"),
+      test("apps/skillset/src/__tests__/contract.test.ts", "CLI check/verify command coverage"),
+      test("packages/workbench/src/__tests__/presets.test.ts", "Workbench presets"),
+      test("packages/workbench/src/__tests__/lint-bridge.test.ts", "Workbench lint bridge"),
+      test("packages/workbench/src/__tests__/parser.test.ts", "Workbench parser diagnostics"),
+      test("packages/workbench/src/__tests__/schema.test.ts", "Workbench source contract diagnostics"),
+      test("packages/workbench/src/__tests__/compatibility.test.ts", "Workbench provider compatibility diagnostics"),
+      test("packages/workbench/src/__tests__/resource-runtime.test.ts", "Workbench resource and runtime diagnostics"),
+      test("packages/workbench/src/__tests__/fixtures.test.ts", "Workbench clean and invalid fixtures"),
+      test("packages/workbench/src/__tests__/ast-grep.test.ts", "Workbench ast-grep adapter proof"),
+      test("packages/workbench/src/__tests__/markdown.test.ts", "Workbench Markdown diagnostics")
+    ],
     id: "workflows",
     kind: "workflow",
     renderOwner: "apps/skillset/src/cli-core.ts",
@@ -8047,13 +8059,14 @@ function readCompileConfig(record, label) {
   if (compile === undefined) {
     return {
       build: "updated",
+      features: { promptArguments: true },
       skillset: { metadata: true },
       targets: [...TARGET_NAMES],
       unsupportedDestination: "error"
     };
   }
   for (const key of Object.keys(compile)) {
-    if (key !== "build" && key !== "skillset" && key !== "targets" && key !== "unsupportedDestination") {
+    if (key !== "build" && key !== "features" && key !== "skillset" && key !== "targets" && key !== "unsupportedDestination") {
       throw new Error(`skillset: unsupported compile key ${key} in ${label}`);
     }
   }
@@ -8063,6 +8076,7 @@ function readCompileConfig(record, label) {
   }
   return {
     build: readCompileBuildMode(compile, `${label}.compile.build`),
+    features: readCompileFeatureConfig(compile, `${label}.compile.features`),
     skillset: readCompileSkillsetConfig(compile, `${label}.compile.skillset`),
     targets: readCompileTargetNames(compile, `${label}.compile.targets`),
     unsupportedDestination
@@ -8356,6 +8370,26 @@ function readCompileSkillsetConfig(record, label) {
   }
   return { metadata };
 }
+function readCompileFeatureConfig(record, label) {
+  const value = record.features;
+  if (value === undefined)
+    return { promptArguments: true };
+  if (!isJsonRecord(value)) {
+    throw new Error(`skillset: expected ${label} to be an object`);
+  }
+  for (const key of Object.keys(value)) {
+    if (key !== "promptArguments") {
+      throw new Error(`skillset: unsupported compile feature key ${key} in ${label}`);
+    }
+  }
+  const promptArguments = value.promptArguments;
+  if (promptArguments === undefined)
+    return { promptArguments: true };
+  if (typeof promptArguments !== "boolean") {
+    throw new Error(`skillset: expected ${label}.promptArguments to be a boolean`);
+  }
+  return { promptArguments };
+}
 function readUnsupportedDestinationPolicy(record, label) {
   const value = record.unsupportedDestination;
   if (value === undefined)
@@ -9111,7 +9145,7 @@ function targetNativeSurface(relativePath) {
 }
 
 // packages/core/src/render-result-collector.ts
-var LOCK_FILE = ".skillset.lock";
+var LOCK_FILE = "skillset.lock";
 var TARGETS2 = ["claude", "codex"];
 function collectRenderResults(graph, rendered, options) {
   const mapOutputPath = options.mapOutputPath ?? ((path) => path);
@@ -9705,7 +9739,7 @@ function renderValidatedToml(value, label) {
 function validateGeneratedStructuredOutput(args) {
   const label = structuredOutputLabel(args);
   try {
-    if (args.targetPath.endsWith(".json") || args.targetPath.endsWith(".skillset.lock")) {
+    if (args.targetPath.endsWith(".json") || args.targetPath.endsWith("skillset.lock")) {
       validateJson(args.content, label);
     } else if (args.targetPath.endsWith(".yaml") || args.targetPath.endsWith(".yml")) {
       validateYaml(args.content, label);
@@ -9807,7 +9841,7 @@ function structuredOutputLabel(args) {
 }
 
 // packages/core/src/output-safety.ts
-var WORKSPACE_LOCK_FILE = ".skillset.lock";
+var WORKSPACE_LOCK_FILE = "skillset.lock";
 var OUTPUT_BACKUP_ROOT = ".skillset/build/backups";
 async function readManagedOutputState(rootPath, liveOutputRoots, includeWorkspaceLock, outPath) {
   const paths = new Set;
@@ -10318,7 +10352,7 @@ var dynamicArgumentsEntry = {
   evidence: DYNAMIC_EVIDENCE,
   forms: {
     claude: {
-      pattern: /\$ARGUMENTS(?:\b|\[[^\]]+\]|\.[A-Za-z_][A-Za-z0-9_-]*)/gu
+      pattern: /\$ARGUMENTS(?:\[[^\]]+\]|\.[A-Za-z_][A-Za-z0-9_-]*|\b)/gu
     }
   },
   intent: "dynamic.arguments",
@@ -10330,7 +10364,7 @@ var dynamicPositionalEntry = {
   evidence: DYNAMIC_EVIDENCE,
   forms: {
     claude: {
-      pattern: /(?<![\w$])\$[0-9]+\b/gu
+      pattern: /(?<![\w$])\$[01]\b(?!\.\d)/gu
     }
   },
   intent: "dynamic.positional",
@@ -11459,8 +11493,25 @@ async function resolveVariable(token, key, context, renderContext) {
     if (value !== undefined)
       return value;
   }
+  if (key.startsWith("$ARGUMENTS")) {
+    return promptArgumentsVariable(token, key, context);
+  }
   throw new Error(`skillset: unknown preprocess variable ${token} in ${relative5(context.rootPath, context.sourcePath)}`);
 }
+function promptArgumentsVariable(token, key, context) {
+  if (!isPromptArgumentsVariable(key)) {
+    throw new Error(`skillset: invalid prompt arguments variable ${token} in ${relative5(context.rootPath, context.sourcePath)}`);
+  }
+  if (context.promptArguments === false) {
+    throw new Error(`skillset: prompt arguments variable ${token} in ${relative5(context.rootPath, context.sourcePath)} requires compile.features.promptArguments`);
+  }
+  if (context.target === "claude")
+    return key;
+  return `{{${key}}}`;
+}
+function isPromptArgumentsVariable(key) {
+  return /^\$ARGUMENTS(?:\b|\[[0-9]+\]|\.[A-Za-z_][A-Za-z0-9_-]*)$/u.test(key);
+}
 function readPathValue(record, path) {
   let current = record;
   for (const segment of path.split(".")) {
@@ -12110,7 +12161,7 @@ function renderRepositoryReadmes(graph) {
       "",
       "- `.claude-plugin/marketplace.json` indexes the generated plugins.",
       "- `plugins/<plugin-id>/` contains each Claude plugin bundle.",
-      "- `.skillset.lock` records deterministic generated-state provenance.",
+      "- `skillset.lock` records deterministic generated-state provenance.",
       ""
     ].join(`
 `)));
@@ -12122,7 +12173,7 @@ function renderRepositoryReadmes(graph) {
       "Generated Codex plugin repository.",
       "",
       "- `plugins/<plugin-id>/` contains each Codex plugin bundle.",
-      "- `.skillset.lock` records deterministic generated-state provenance.",
+      "- `skillset.lock` records deterministic generated-state provenance.",
       ""
     ].join(`
 `)));
@@ -12666,10 +12717,17 @@ async function renderSkillMarkdown(graph, plugin, skill, target) {
     rootPath: graph.rootPath,
     sourcePath: skill.sourcePath,
     sourceRoot: graph.sourceRoot,
+    target,
+    promptArguments: graph.root.compile.features.promptArguments,
     ...plugin === undefined ? {} : { pluginPath: plugin.path }
   });
-  const dependencyNotice = target === "codex" && plugin !== undefined ? renderCodexDependencyNotice(graph, plugin) : undefined;
-  const body = dependencyNotice === undefined ? preprocessedBody : `${dependencyNotice}
+  const notices = [
+    target === "codex" && plugin !== undefined ? renderCodexDependencyNotice(graph, plugin) : undefined,
+    target === "codex" ? renderCodexPromptArgumentsNotice(preprocessedBody) : undefined
+  ].filter((notice) => notice !== undefined);
+  const body = notices.length === 0 ? preprocessedBody : `${notices.join(`
+
+`)}
 
 ${preprocessedBody}`;
   const linkedBody = rewriteResourceLinks(body, skill.resources, skill.sourcePath);
@@ -12680,6 +12738,12 @@ ${preprocessedBody}`;
     transforms: translated.transforms
   };
 }
+function renderCodexPromptArgumentsNotice(body) {
+  if (!/\{\{\$ARGUMENTS(?:\}\}|\[[0-9]+\]\}\}|\.[A-Za-z_][A-Za-z0-9_-]*\}\})/u.test(body)) {
+    return;
+  }
+  return "Before using commands, replace `{{$ARGUMENTS...}}` placeholders with the user's supplied arguments.";
+}
 function renderClaudeSkillPolicy(skill, targetOptions) {
   const label = skill.sourcePath;
   const implicitInvocation = readImplicitInvocation(skill.frontmatter, "claude", label);
@@ -12717,6 +12781,8 @@ async function renderCodexSkillAgentFile(graph, plugin, skill, target, sourceDir
     rootPath: graph.rootPath,
     sourcePath: sourceOpenAiPath,
     sourceRoot: graph.sourceRoot,
+    target,
+    promptArguments: graph.root.compile.features.promptArguments,
     ...plugin === undefined ? {} : { pluginPath: plugin.path }
   }), sourceOpenAiPath) : {};
   const merged = mergeRecords(source2, generated);
@@ -13097,6 +13163,9 @@ function renderLockFiles(graph, lockRoots) {
   for (const [outputRoot, lock] of [...lockRoots.entries()].sort(([left], [right]) => compareStrings(left, right))) {
     const value = {
       buildMode: graph.root.compile.build,
+      features: {
+        promptArguments: graph.root.compile.features.promptArguments
+      },
       generatedBy: GENERATED_BY2,
       items: lock.items.map((item) => stripUndefinedLockItem(item)).sort((left, right) => compareStrings(String(left.outputPath), String(right.outputPath))),
       selectedTargets: [...graph.root.compile.targets],
@@ -13106,7 +13175,7 @@ function renderLockFiles(graph, lockRoots) {
       sourceRoot: graph.sourceRoot,
       target: lock.target
     };
-    rendered.push(textFile(join6(outputRoot, ".skillset.lock"), renderValidatedJson(value, `${outputRoot}/.skillset.lock`)));
+    rendered.push(textFile(join6(outputRoot, "skillset.lock"), renderValidatedJson(value, `${outputRoot}/skillset.lock`)));
   }
   return rendered;
 }
@@ -13514,7 +13583,7 @@ async function exists3(path) {
   }
 }
 function validateRenderedFile(file) {
-  if (file.sourcePath !== undefined || file.path.endsWith(".skillset.lock")) {
+  if (file.sourcePath !== undefined || file.path.endsWith("skillset.lock")) {
     validateGeneratedStructuredOutput({
       content: textDecoder.decode(file.content),
       targetPath: file.path,
@@ -14413,7 +14482,7 @@ async function outputRootsFor(rootPath, outputs, plugins, standaloneSkills, rule
   for (const outputRoot of configuredOutputRoots(outputs)) {
     if (roots.has(outputRoot.path))
       continue;
-    if (await exists5(join8(resolveInside(rootPath, outputRoot.path), ".skillset.lock"))) {
+    if (await exists5(join8(resolveInside(rootPath, outputRoot.path), "skillset.lock"))) {
       roots.set(outputRoot.path, outputRoot);
     }
   }
@@ -14671,7 +14740,7 @@ async function diffSkillsetResult(rootPath, options = {}) {
     }
   };
 }
-async function checkSkillsetResult(rootPath, options = {}) {
+async function verifySkillsetResult(rootPath, options = {}) {
   const graph = await loadBuildGraph(rootPath, options);
   const diagnostics = [...graph.warnings.map(sourceWarningDiagnostic)];
   const outPath = outPathMapper(options);
@@ -14724,7 +14793,7 @@ async function checkSkillsetResult(rootPath, options = {}) {
     diagnostics: [...diagnostics, ...driftDiagnostics],
     renderResults: renderResultsWithDiagnostics,
     ok: failures.length === 0,
-    operation: "check",
+    operation: "verify",
     writes: {
       deletedPaths: [],
       mode: "read",
@@ -14853,12 +14922,12 @@ function outputPathsForLock(outputRoot, lock) {
   return paths;
 }
 function outputRootForLockPath(lockPath) {
-  if (lockPath === ".skillset.lock")
+  if (lockPath === "skillset.lock")
     return ".";
   return dirname7(lockPath).replaceAll("\\", "/");
 }
 function isLockFilePath(path) {
-  return path === ".skillset.lock" || path.endsWith("/.skillset.lock");
+  return path === "skillset.lock" || path.endsWith("/skillset.lock");
 }
 async function diagnoseMissingManagedOutputs(rootPath, rendered, previousManagedPaths) {
   const diagnostics = [];
@@ -15492,12 +15561,12 @@ var CLAUDE_DYNAMIC_PATTERNS = [
   {
     code: "claude-arguments",
     label: "$ARGUMENTS",
-    pattern: /\$ARGUMENTS(?:\b|\[[^\]]+\]|\.[A-Za-z_][A-Za-z0-9_-]*)/
+    pattern: /\$ARGUMENTS(?:\[[^\]]+\]|\.[A-Za-z_][A-Za-z0-9_-]*|\b)/
   },
   {
     code: "claude-positional-argument",
     label: "$0/$1 positional arguments",
-    pattern: /(^|[^\w$])\$[0-9]+\b/
+    pattern: /(^|[^\w$])\$[01]\b(?!\.\d)/
   },
   {
     code: "claude-env-substitution",
@@ -15512,6 +15581,7 @@ var CLAUDE_DYNAMIC_PATTERNS = [
 ];
 var FENCE_PATTERN2 = /^\s*(?:```|~~~)/u;
 var INLINE_CODE_PATTERN2 = /`[^`]*`/gu;
+var SKILLSET_PROMPT_ARGUMENT_PATTERN = /\{\{\s*\$ARGUMENTS(?:\b|\[[0-9]+\]|\.[A-Za-z_][A-Za-z0-9_-]*)\s*\}\}/gu;
 async function lintSkillset(rootPath, options = {}) {
   const graph = await loadBuildGraph(rootPath, options);
   const result = await inspectBuildGraph(graph);
@@ -15696,7 +15766,18 @@ function lintSkill(graph, skill, featureId) {
   if (!skill.targets.codex.enabled)
     return issues;
   issues.push(...lintCodexAllowedTools(graph, skill));
-  const searchableBody = maskMarkdownCodeRegions(skill.body);
+  const markdownSearchableBody = maskMarkdownCodeRegions(skill.body);
+  if (!graph.root.compile.features.promptArguments && hasSkillsetPromptArguments(skill.body)) {
+    const path2 = relative10(graph.rootPath, skill.sourcePath);
+    issues.push({
+      code: "prompt-arguments-disabled",
+      featureId,
+      severity: "error",
+      path: path2,
+      message: `${path2} uses Skillset prompt argument placeholders while compile.features.promptArguments is false. ` + "Enable compile.features.promptArguments or remove the {{$ARGUMENTS...}} placeholders."
+    });
+  }
+  const searchableBody = maskSkillsetPromptArguments(markdownSearchableBody);
   const matches = CLAUDE_DYNAMIC_PATTERNS.filter(({ pattern }) => pattern.test(searchableBody));
   if (matches.length === 0)
     return issues;
@@ -15711,6 +15792,14 @@ function lintSkill(graph, skill, featureId) {
   });
   return issues;
 }
+function maskSkillsetPromptArguments(body) {
+  SKILLSET_PROMPT_ARGUMENT_PATTERN.lastIndex = 0;
+  return body.replaceAll(SKILLSET_PROMPT_ARGUMENT_PATTERN, "");
+}
+function hasSkillsetPromptArguments(body) {
+  SKILLSET_PROMPT_ARGUMENT_PATTERN.lastIndex = 0;
+  return SKILLSET_PROMPT_ARGUMENT_PATTERN.test(body);
+}
 function maskMarkdownCodeRegions(body) {
   let inFence = false;
   return body.split(/\r?\n/u).map((line) => {
@@ -15803,7 +15892,7 @@ async function explainPath(rootPath, inputPath, options = {}) {
       entries: asGenerated.map((item) => item.entry),
       features: featureCapabilitiesForPath(graph, target, asGenerated, matchedRenderResults),
       renderResults: matchedRenderResults,
-      notes: [`Generated output; rebuild with skillset build, verify with skillset check.`]
+      notes: [`Generated output; rebuild with skillset build, verify with skillset verify.`]
     };
   }
   const prefixMatch = items.filter((item) => item.sourcePath.startsWith(`${target}/`));
@@ -15902,7 +15991,7 @@ async function suggestSource(rootPath, inputPath, options = {}) {
       generatedPath,
       ...lockPath2 === undefined ? {} : { lockPath: lockPath2 },
       message: "Generated body matches the source body; no source edit is needed.",
-      nextSteps: ["Run `skillset diff` or `skillset check` to inspect any remaining generated drift."],
+      nextSteps: ["Run `skillset diff` or `skillset verify` to inspect any remaining generated drift."],
       sourcePath,
       status: "suggestible",
       wouldWrite: false,
@@ -16036,7 +16125,7 @@ function errorMessage(error) {
 function collectLockItems(rendered) {
   const matches = [];
   for (const file of rendered) {
-    if (!file.path.endsWith(".skillset.lock"))
+    if (!file.path.endsWith("skillset.lock"))
       continue;
     let parsed;
     try {
@@ -16105,7 +16194,7 @@ function joinOutputRoot2(outputRoot, file) {
 function lockPathForEntry(entry) {
   if (entry === undefined)
     return;
-  return joinOutputRoot2(entry.outputRoot, ".skillset.lock");
+  return joinOutputRoot2(entry.outputRoot, "skillset.lock");
 }
 function refusedSourceSuggestion(generatedPath, entries, message, nextSteps, sourcePath) {
   const lockPath = lockPathForEntry(entries[0]);
@@ -16244,7 +16333,7 @@ function normalizeRepoPath(rootPath, inputPath) {
 var textDecoder4 = new TextDecoder;
 
 // packages/core/src/normalized-output-tree.ts
-var DEFAULT_STRUCTURED_JSON_BASENAMES = new Set([".skillset.lock"]);
+var DEFAULT_STRUCTURED_JSON_BASENAMES = new Set(["skillset.lock"]);
 
 // packages/core/src/deterministic-projection.ts
 var textEncoder4 = new TextEncoder;
@@ -17601,7 +17690,7 @@ function kindForSourceUnitId(id) {
   return "root-config";
 }
 async function sourceInventoryFromLock(rootPath, _options) {
-  const lockPath = resolveInside(rootPath, ".skillset.lock");
+  const lockPath = resolveInside(rootPath, "skillset.lock");
   if (!await exists7(lockPath))
     return;
   let parsed;
@@ -17642,7 +17731,7 @@ async function sourceInventoryFromLock(rootPath, _options) {
   if (units.length === 0)
     return;
   return {
-    baseline: { hashSchema, kind: "source-inventory", label: ".skillset.lock" },
+    baseline: { hashSchema, kind: "source-inventory", label: "skillset.lock" },
     inventory: { hashSchema, units }
   };
 }
@@ -18377,7 +18466,7 @@ async function importSource(options) {
       nextChecks: [
         "skillset lint",
         "skillset build",
-        "skillset check"
+        "skillset verify"
       ],
       preservedTargetNativeFields: classification.targetNative,
       sourcePath,
@@ -19415,7 +19504,7 @@ async function maybeCandidate(candidates, rootPath, path2, kind) {
   candidates.push({ kind, path: relative14(rootPath, absolutePath).replaceAll("\\", "/") });
 }
 async function isManagedCandidate(path2) {
-  return await pathExists(join15(path2, ".skillset.lock")) || await pathExists(join15(dirname11(path2), ".skillset.lock"));
+  return await pathExists(join15(path2, "skillset.lock")) || await pathExists(join15(dirname11(path2), "skillset.lock"));
 }
 function compareCandidate(left, right) {
   return `${left.kind}:${left.path}` < `${right.kind}:${right.path}` ? -1 : `${left.kind}:${left.path}` > `${right.kind}:${right.path}` ? 1 : 0;
@@ -19544,6 +19633,7 @@ function createReadme(name, targets) {
     "skillset build --dry-run",
     "skillset build --yes",
     "skillset check",
+    "skillset verify",
     "skillset change status",
     "```",
     "",
@@ -19574,7 +19664,7 @@ function createAgentsGuide(name) {
     "- Treat `changes/` as Skillset-managed change and release state.",
     "- Treat generated target directories as outputs; do not hand-edit them as source truth.",
     "- Run `skillset build --dry-run` before writing generated outputs.",
-    "- Run `skillset check` before committing source changes.",
+    "- Run `skillset check` and `skillset verify` before committing source changes.",
     "- Add pending change entries with `skillset change add` when source units change and the repo uses Skillset release tracking.",
     ""
   ].join(`
@@ -19785,6 +19875,7 @@ async function importCandidate(rootPath, acquisition, candidate, cutover, previe
     try {
       const destination = await importInstructionFile(rootPath, candidate.path);
       await writeMarkdownSourceOrigin2(join16(rootPath, destination), sourceOriginFor(acquisition, candidate.path));
+      await normalizeImportedPromptArguments(join16(rootPath, destination));
       cutover.push(candidate.path);
       previewSources.push(destination);
       return { candidate, destination, detail: destination, renderResults: [], ok: true, units: [] };
@@ -19811,6 +19902,7 @@ async function importCandidate(rootPath, acquisition, candidate, cutover, previe
       for (const file of report.copiedFiles) {
         if (basename8(file) !== "SKILL.md")
           continue;
+        await normalizeImportedPromptArguments(join16(report.targetPath, file));
         previewSources.push(relative15(rootPath, join16(report.targetPath, file)).replaceAll("\\", "/"));
       }
     }
@@ -19865,12 +19957,45 @@ function sourceOriginRecord3(origin) {
     ...origin.repo === undefined ? {} : { repo: origin.repo }
   };
 }
+async function normalizeImportedPromptArguments(path2) {
+  const raw = await readFile17(path2, "utf8");
+  let updated;
+  try {
+    const parts = parseMarkdown(raw, path2);
+    const body = rewriteClaudePromptArguments(parts.body);
+    updated = body === parts.body ? raw : stringifyMarkdown(parts.frontmatter, body);
+  } catch {
+    updated = rewriteClaudePromptArguments(raw);
+  }
+  if (updated !== raw)
+    await writeFile8(path2, updated);
+}
+function rewriteClaudePromptArguments(content) {
+  const pattern = /\$ARGUMENTS(?:\[[0-9]+\]|\.[A-Za-z_][A-Za-z0-9_-]*|\b(?![\[.]))/gu;
+  let rewritten = "";
+  let cursor = 0;
+  for (const match of content.matchAll(pattern)) {
+    const token = match[0];
+    const index = match.index;
+    if (isAlreadySkillsetPromptArgument(content, index, index + token.length))
+      continue;
+    rewritten += content.slice(cursor, index);
+    rewritten += `{{${token}}}`;
+    cursor = index + token.length;
+  }
+  return `${rewritten}${content.slice(cursor)}`;
+}
+function isAlreadySkillsetPromptArgument(content, start, end) {
+  const before = content.slice(Math.max(0, start - 4), start);
+  const after = content.slice(end, Math.min(content.length, end + 4));
+  return /\{\{\s*$/u.test(before) && /^\s*\}\}/u.test(after);
+}
 async function buildTransformPreviews(rootPath, paths) {
   const previews = [];
   for (const path2 of paths) {
     const raw = await readFile17(join16(rootPath, path2), "utf8");
     const body = basename8(path2) === "SKILL.md" ? markdownBody(raw, path2) : raw;
-    const matches = recognizeTransforms(body, "claude");
+    const matches = recognizeTransforms(maskSkillsetPromptArguments2(body), "claude");
     if (matches.length === 0)
       continue;
     const transformable = matches.some((match) => match.lowering !== "none");
@@ -19892,6 +20017,9 @@ async function buildTransformPreviews(rootPath, paths) {
   }
   return previews;
 }
+function maskSkillsetPromptArguments2(body) {
+  return body.replaceAll(/\{\{\s*\$ARGUMENTS(?:\[[0-9]+\]|\.[A-Za-z_][A-Za-z0-9_-]*|\b)\s*\}\}/gu, "");
+}
 async function declareClaudeDialect(path2) {
   const raw = await readFile17(path2, "utf8");
   try {
@@ -19986,7 +20114,7 @@ function renderAdoptReportMarkdown(report, opts) {
   }
   if (report.transformPreviews.length > 0) {
     lines.push("## Transforms (preview)", "");
-    lines.push("Bodies are untouched. Files with transformable constructs were marked `dialect: claude`; the build lowers their Codex projection through these forms.", "");
+    lines.push("Claude `$ARGUMENTS` forms are normalized to Skillset prompt argument placeholders. Other bodies are untouched. Files with transformable constructs were marked `dialect: claude`; the build lowers their Codex projection through these forms.", "");
     for (const preview of report.transformPreviews) {
       lines.push(`### \`${preview.path}\``, "");
       if (preview.dialectDeclared) {
@@ -20025,7 +20153,7 @@ function renderAdoptReportMarkdown(report, opts) {
       lines.push(`- ${summary}`);
     }
     lines.push("");
-    lines.push("Full structured render results are in `report.json` and in the isolated `.skillset.lock` files when the isolated build completes.", "");
+    lines.push("Full structured render results are in `report.json` and in the isolated `skillset.lock` files when the isolated build completes.", "");
   }
   lines.push("## Cutover", "");
   lines.push(`1. Review the generated mirror under \`${ISOLATED_OUT_ROOT}/\` against the originals.`);
@@ -20038,7 +20166,7 @@ function renderAdoptReportMarkdown(report, opts) {
     lines.push("2. No original paths need to move before a live build.");
   }
   lines.push("3. Run `skillset build --yes` to write live output.", "", "Until the originals move, live builds refuse to overwrite them as unmanaged files \u2014 that protection is the safety net; nothing is lost by building too early.", "");
-  lines.push("## Next steps", "", "- `skillset lint`", "- `skillset check --isolated`", "- `skillset ci`", "");
+  lines.push("## Next steps", "", "- `skillset lint`", "- `skillset verify --isolated`", "- `skillset ci`", "");
   return `${lines.join(`
 `).trimEnd()}
 `;
@@ -20803,7 +20931,7 @@ function readHookRunEvent(value) {
 }
 // apps/skillset/src/runtime-hooks/print.ts
 var PRE_COMMIT_COMMAND = "skillset change check --staged";
-var PRE_PUSH_COMMAND = "skillset change check --since origin/main && skillset check && skillset doctor";
+var PRE_PUSH_COMMAND = "skillset change check --since origin/main && skillset check && skillset verify && skillset doctor";
 var RUNTIME_POST_TOOL_USE_COMMAND = "skillset hooks run post-tool-use";
 var RUNTIME_STOP_COMMAND = "skillset hooks run stop";
 function renderHookPrint(options) {
@@ -21041,7 +21169,12 @@ async function runHookEvent(event, options = {}) {
   const checkArgs = ["check", "--root", "."];
   ranCommands.push(checkArgs.join(" "));
   const check = await runner(checkArgs, commandOptions({ allowFailure: false, options, rootPath }));
-  return result({ context, event, exitCode: check, gate, ranCommands });
+  if (check !== 0)
+    return result({ context, event, exitCode: check, gate, ranCommands });
+  const verifyArgs = ["verify", "--root", "."];
+  ranCommands.push(verifyArgs.join(" "));
+  const verify = await runner(verifyArgs, commandOptions({ allowFailure: false, options, rootPath }));
+  return result({ context, event, exitCode: verify, gate, ranCommands });
 }
 function commandOptions(args) {
   return {
@@ -21060,10 +21193,220 @@ function result(args) {
     sourceGateOk: args.gate.ok
   };
 }
+// apps/skillset/src/new-source.ts
+import { mkdir as mkdir9, stat as stat16, writeFile as writeFile10 } from "fs/promises";
+import { dirname as dirname14, join as join19 } from "path";
+var SKILL_PRESETS = new Set([
+  "assets",
+  "evals",
+  "examples-file",
+  "minimal",
+  "reference-file",
+  "references",
+  "scripts",
+  "support"
+]);
+async function scaffoldSourceUnit(rootPath, options) {
+  if (options.scope !== undefined && options.scope !== "repo") {
+    throw new Error("skillset: new currently supports only --scope repo");
+  }
+  if (options.kind === "hook") {
+    throw new Error("skillset: new hook is not available yet; current hook source is hooks/hooks.json");
+  }
+  const id = resolveSourceId(options);
+  const displayName = resolveDisplayName(options, id);
+  const sourceDir = await detectWorkspaceSourceDir(rootPath, options.skillsetOptions ?? {});
+  await assertWorkspaceInitialized(rootPath, sourceDir);
+  const sourceRoot = sourceDir === "." ? "skillset" : join19(sourceDir, "src");
+  const plans = options.kind === "skill" ? await planSkill(rootPath, sourceRoot, id, displayName, options) : planAgent(sourceRoot, id, displayName, options);
+  for (const plan of plans) {
+    if (await fileExists2(resolveInside(rootPath, plan.path))) {
+      throw new Error(`skillset: refusing to overwrite existing source file ${plan.path}`);
+    }
+  }
+  if (options.write === true) {
+    for (const plan of plans) {
+      const absolutePath = resolveInside(rootPath, plan.path);
+      await mkdir9(dirname14(absolutePath), { recursive: true });
+      await writeFile10(absolutePath, plan.content);
+    }
+  }
+  return {
+    displayName,
+    files: plans.map((plan) => ({ path: plan.path })),
+    id,
+    kind: options.kind,
+    rootPath,
+    sourceRoot,
+    write: options.write === true
+  };
+}
+function resolveSourceId(options) {
+  if (options.id !== undefined)
+    return validateSlug(options.id, `${options.kind} id`);
+  const name = options.name ?? options.displayName;
+  if (name === undefined || name.trim().length === 0) {
+    throw new Error(`skillset: new ${options.kind} requires a name or --id`);
+  }
+  return validateSlug(kebabCase(name), `${options.kind} id`);
+}
+function resolveDisplayName(options, id) {
+  if (options.displayName !== undefined && options.displayName.trim().length > 0) {
+    return options.displayName.trim();
+  }
+  if (options.name !== undefined && options.name.trim().length > 0)
+    return options.name.trim();
+  return titleFromId(id);
+}
+async function planSkill(rootPath, sourceRoot, id, displayName, options) {
+  const container = options.container === undefined ? undefined : validateSlug(options.container, "new --in container");
+  if (container !== undefined)
+    await assertPluginContainer(rootPath, sourceRoot, container);
+  const skillRoot = container === undefined ? join19(sourceRoot, "skills", id) : join19(sourceRoot, "plugins", container, "skills", id);
+  const presets = readSkillPresets(options.presets);
+  const files = [
+    {
+      content: renderSkill(id, displayName),
+      path: join19(skillRoot, "SKILL.md")
+    }
+  ];
+  for (const preset of presets) {
+    if (preset === "minimal")
+      continue;
+    if (preset === "support" || preset === "references") {
+      files.push({ content: "", path: join19(skillRoot, "references", ".gitkeep") });
+    }
+    if (preset === "support" || preset === "assets") {
+      files.push({ content: "", path: join19(skillRoot, "assets", ".gitkeep") });
+    }
+    if (preset === "support" || preset === "scripts") {
+      files.push({ content: "", path: join19(skillRoot, "scripts", ".gitkeep") });
+    }
+    if (preset === "evals") {
+      files.push({ content: `{
+  "evals": []
+}
+`, path: join19(skillRoot, "evals", "evals.json") });
+    }
+    if (preset === "reference-file") {
+      files.push({ content: `# ${displayName} Reference
+
+Add concise reference material here.
+`, path: join19(skillRoot, "REFERENCE.md") });
+    }
+    if (preset === "examples-file") {
+      files.push({ content: `# ${displayName} Examples
+
+Add examples here.
+`, path: join19(skillRoot, "EXAMPLES.md") });
+    }
+  }
+  return uniquePlans(files);
+}
+function planAgent(sourceRoot, id, displayName, options) {
+  if (options.container !== undefined) {
+    throw new Error("skillset: new agent does not support --in; project agents live at the repo source root");
+  }
+  if (options.presets !== undefined && options.presets.length > 0) {
+    throw new Error("skillset: new agent does not support --preset");
+  }
+  return [
+    {
+      content: renderAgent(id, displayName),
+      path: join19(sourceRoot, "agents", `${id}.md`)
+    }
+  ];
+}
+async function assertPluginContainer(rootPath, sourceRoot, container) {
+  const pluginPath = join19(sourceRoot, "plugins", container);
+  try {
+    const stats = await stat16(resolveInside(rootPath, pluginPath));
+    if (stats.isDirectory() && await hasPluginManifest(rootPath, pluginPath))
+      return;
+  } catch {}
+  throw new Error(`skillset: new --in container does not exist or has no skillset.yaml/config.yaml: ${pluginPath}`);
+}
+async function assertWorkspaceInitialized(rootPath, sourceDir) {
+  const manifests = sourceDir === "." ? ["skillset.yaml"] : [join19(sourceDir, "skillset.yaml"), join19(sourceDir, "config.yaml")];
+  for (const manifest of manifests) {
+    if (await fileExists2(resolveInside(rootPath, manifest)))
+      return;
+  }
+  throw new Error("skillset: new requires an initialized Skillset workspace; run skillset init --yes for an existing repo or skillset create for a dedicated repo");
+}
+function readSkillPresets(values) {
+  const raw = values === undefined || values.length === 0 ? ["minimal"] : values.flatMap((value) => value.split(",")).map((value) => value.trim()).filter(Boolean);
+  const presets = [];
+  const seen = new Set;
+  for (const value of raw) {
+    if (!SKILL_PRESETS.has(value)) {
+      throw new Error("skillset: expected --preset minimal, support, references, assets, scripts, evals, reference-file, or examples-file");
+    }
+    if (seen.has(value))
+      continue;
+    seen.add(value);
+    presets.push(value);
+  }
+  return presets;
+}
+function uniquePlans(plans) {
+  const seen = new Set;
+  const unique = [];
+  for (const plan of plans) {
+    if (seen.has(plan.path))
+      continue;
+    seen.add(plan.path);
+    unique.push(plan);
+  }
+  return unique;
+}
+function renderSkill(id, displayName) {
+  const description = `Use when working with ${displayName} workflows.`;
+  return `---
+name: ${id}
+title: ${yamlString(displayName)}
+description: ${yamlString(description)}
+---
+
+# ${displayName}
+
+Use this skill when working with ${displayName} workflows.
+
+## Workflow
+
+- Add the domain-specific guidance here.
+`;
+}
+function renderAgent(id, displayName) {
+  const description = `Use this agent for ${displayName} work.`;
+  return `---
+name: ${id}
+description: ${yamlString(description)}
+---
+
+Use this agent for ${displayName} work.
+`;
+}
+function kebabCase(value) {
+  return value.trim().toLowerCase().replace(/['\u2019]/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function titleFromId(id) {
+  return id.split("-").filter((part) => part.length > 0).map((part) => `${part[0]?.toUpperCase() ?? ""}${part.slice(1)}`).join(" ");
+}
+function yamlString(value) {
+  return JSON.stringify(value);
+}
+async function fileExists2(path2) {
+  return Bun.file(path2).exists();
+}
+async function hasPluginManifest(rootPath, pluginPath) {
+  return await fileExists2(resolveInside(rootPath, join19(pluginPath, "skillset.yaml"))) || await fileExists2(resolveInside(rootPath, join19(pluginPath, "config.yaml")));
+}
+
 // apps/skillset/src/release.ts
-import { appendFile as appendFile2, mkdir as mkdir9, readFile as readFile20, rm as rm6, stat as stat16, writeFile as writeFile10 } from "fs/promises";
+import { appendFile as appendFile2, mkdir as mkdir10, readFile as readFile20, rm as rm6, stat as stat17, writeFile as writeFile11 } from "fs/promises";
 import { createHash as createHash7 } from "crypto";
-import { dirname as dirname14, join as join19 } from "path";
+import { dirname as dirname15, join as join20 } from "path";
 var HISTORY_FILE3 = "changes/history.jsonl";
 var RELEASES_FILE = "changes/releases.jsonl";
 var RELEASE_AMENDMENTS_FILE = "changes/release-amendments.jsonl";
@@ -21147,9 +21490,9 @@ async function amendReleaseRecord(rootPath, options) {
   const notes = await resolveChangeReason(rootPath, options.reason);
   const now = new Date().toISOString();
   const sourceDir = storageOptions.sourceDir ?? ".skillset";
-  const amendmentPath = join19(sourceDir, RELEASE_AMENDMENTS_FILE).replaceAll("\\", "/");
+  const amendmentPath = join20(sourceDir, RELEASE_AMENDMENTS_FILE).replaceAll("\\", "/");
   const absolutePath = resolveInside(rootPath, amendmentPath);
-  await mkdir9(dirname14(absolutePath), { recursive: true });
+  await mkdir10(dirname15(absolutePath), { recursive: true });
   await appendFile2(absolutePath, `${JSON.stringify({
     amendedAt: now,
     id: release.id,
@@ -21294,9 +21637,9 @@ function nextReleaseState(state, scopesToWrite, updatedAt) {
 async function appendHistory(rootPath, sourceDir, entries, appliedAt, files) {
   if (entries.length === 0)
     return;
-  const relativePath2 = join19(sourceDir, HISTORY_FILE3).replaceAll("\\", "/");
+  const relativePath2 = join20(sourceDir, HISTORY_FILE3).replaceAll("\\", "/");
   const absolutePath = resolveInside(rootPath, relativePath2);
-  await mkdir9(dirname14(absolutePath), { recursive: true });
+  await mkdir10(dirname15(absolutePath), { recursive: true });
   const lines = entries.flatMap((entry) => entry.id === undefined || entry.bump === undefined ? [] : [
     JSON.stringify({
       appliedAt,
@@ -21319,9 +21662,9 @@ async function appendHistory(rootPath, sourceDir, entries, appliedAt, files) {
 async function appendReleaseRecord(rootPath, sourceDir, plan, appliedAt, files) {
   if (plan.scopes.length === 0)
     return;
-  const relativePath2 = join19(sourceDir, RELEASES_FILE).replaceAll("\\", "/");
+  const relativePath2 = join20(sourceDir, RELEASES_FILE).replaceAll("\\", "/");
   const absolutePath = resolveInside(rootPath, relativePath2);
-  await mkdir9(dirname14(absolutePath), { recursive: true });
+  await mkdir10(dirname15(absolutePath), { recursive: true });
   await appendFile2(absolutePath, `${JSON.stringify({
     appliedAt,
     baseline: { hashSchema: SOURCE_HASH_SCHEMA, kind: "source-hashes" },
@@ -21341,12 +21684,12 @@ async function appendReleaseRecord(rootPath, sourceDir, plan, appliedAt, files)
 }
 async function snapshotReleaseFiles(rootPath, sourceDir, entries, includeReleaseState) {
   const paths = new Set([
-    join19(sourceDir, HISTORY_FILE3).replaceAll("\\", "/"),
+    join20(sourceDir, HISTORY_FILE3).replaceAll("\\", "/"),
     ...entries.map((entry) => entry.path)
   ]);
   if (includeReleaseState) {
-    paths.add(join19(sourceDir, STATE_FILE2).replaceAll("\\", "/"));
-    paths.add(join19(sourceDir, RELEASES_FILE).replaceAll("\\", "/"));
+    paths.add(join20(sourceDir, STATE_FILE2).replaceAll("\\", "/"));
+    paths.add(join20(sourceDir, RELEASES_FILE).replaceAll("\\", "/"));
   }
   const snapshots = [];
   for (const path2 of [...paths].sort(compareStrings)) {
@@ -21365,13 +21708,13 @@ async function restoreSnapshots(rootPath, snapshots) {
       await rm6(absolutePath, { force: true });
       continue;
     }
-    await mkdir9(dirname14(absolutePath), { recursive: true });
-    await writeFile10(absolutePath, snapshot.content);
+    await mkdir10(dirname15(absolutePath), { recursive: true });
+    await writeFile11(absolutePath, snapshot.content);
   }
 }
 async function exists13(path2) {
   try {
-    await stat16(path2);
+    await stat17(path2);
     return true;
   } catch (error) {
     if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
@@ -21411,7 +21754,7 @@ function releaseIdFor(scopes) {
 }
 async function readReleaseRecords(rootPath, options = {}) {
   const sourceDir = options.sourceDir ?? ".skillset";
-  const path2 = join19(sourceDir, RELEASES_FILE).replaceAll("\\", "/");
+  const path2 = join20(sourceDir, RELEASES_FILE).replaceAll("\\", "/");
   const absolutePath = resolveInside(rootPath, path2);
   if (!await exists13(absolutePath))
     return [];
@@ -21437,7 +21780,7 @@ async function readReleaseRecords(rootPath, options = {}) {
 }
 async function readReleaseAmendments(rootPath, options = {}) {
   const sourceDir = options.sourceDir ?? ".skillset";
-  const path2 = join19(sourceDir, RELEASE_AMENDMENTS_FILE).replaceAll("\\", "/");
+  const path2 = join20(sourceDir, RELEASE_AMENDMENTS_FILE).replaceAll("\\", "/");
   const absolutePath = resolveInside(rootPath, path2);
   if (!await exists13(absolutePath))
     return new Map;
@@ -21539,9 +21882,9 @@ function isChangeBump(value) {
   return value === "major" || value === "minor" || value === "patch" || value === "none";
 }
 // apps/skillset/src/test-runner.ts
-import { cp, mkdir as mkdir10, mkdtemp as mkdtemp4, readFile as readFile21, rm as rm7, stat as stat17, writeFile as writeFile11 } from "fs/promises";
+import { cp, mkdir as mkdir11, mkdtemp as mkdtemp4, readFile as readFile21, rm as rm7, stat as stat18, writeFile as writeFile12 } from "fs/promises";
 import { createHash as createHash8, randomBytes as randomBytes2 } from "crypto";
-import { dirname as dirname15, join as join20, relative as relative16, resolve as resolve9 } from "path";
+import { dirname as dirname16, join as join21, relative as relative16, resolve as resolve9 } from "path";
 import { tmpdir as tmpdir3 } from "os";
 var TEST_BUILD_DIR = "build/tests";
 var TEST_SCHEMA = 1;
@@ -21559,23 +21902,17 @@ async function runSkillsetTest(rootPath, name, options = {}) {
     targetFilter: declaration.targets
   };
   const runId = makeRunId(declaration.name);
-  const buildRoot = resolveInside(rootPath, join20(sourceDir, TEST_BUILD_DIR));
-  const runsRoot = join20(buildRoot, "runs");
-  const runPath = join20(runsRoot, runId);
-  const workspacePath = join20(runPath, "workspace");
-  const stagingRoot = await mkdtemp4(join20(tmpdir3(), "skillset-test-"));
-  const stagingWorkspacePath = join20(stagingRoot, "workspace");
-  const stagingSourcePath = join20(stagingWorkspacePath, sourceDir);
-  const sourcePath = resolveInside(rootPath, sourceDir);
-  const workspaceLockPath = resolveInside(rootPath, ".skillset.lock");
-  const ignoredSourceBuildPath = resolveInside(rootPath, join20(sourceDir, "build"));
+  const buildRoot = resolveInside(rootPath, testBuildRoot(sourceDir));
+  const runsRoot = join21(buildRoot, "runs");
+  const runPath = join21(runsRoot, runId);
+  const workspacePath = join21(runPath, "workspace");
+  const stagingRoot = await mkdtemp4(join21(tmpdir3(), "skillset-test-"));
+  const stagingWorkspacePath = join21(stagingRoot, "workspace");
+  const workspaceLockPath = resolveInside(rootPath, "skillset.lock");
   try {
-    await mkdir10(stagingWorkspacePath, { recursive: true });
-    await cp(sourcePath, stagingSourcePath, {
-      filter: (path2) => !isSameOrInside2(ignoredSourceBuildPath, path2),
-      recursive: true
-    });
-    await copyIfExists(workspaceLockPath, join20(stagingWorkspacePath, ".skillset.lock"));
+    await mkdir11(stagingWorkspacePath, { recursive: true });
+    await copyTestSource(graph, stagingWorkspacePath);
+    await copyIfExists(workspaceLockPath, join21(stagingWorkspacePath, "skillset.lock"));
     await copyWorkspaceManagedFiles(rootPath, stagingWorkspacePath, workspaceLockPath, sourceDir);
     const assertions = [];
     let generatedFiles = 0;
@@ -21595,13 +21932,13 @@ async function runSkillsetTest(rootPath, name, options = {}) {
     if (assertions.every((assertion) => assertion.ok)) {
       await validateActivationExpectations(stagingWorkspacePath, declaration, buildOptions);
     }
-    await mkdir10(runPath, { recursive: true });
+    await mkdir11(runPath, { recursive: true });
     await cp(stagingWorkspacePath, workspacePath, { recursive: true });
     const activationPath = await writeActivationProbes(runPath, declaration);
     const ok = assertions.every((assertion) => assertion.ok);
-    const reportPath = join20(runPath, "report.json");
-    const reportMarkdownPath = join20(runPath, "report.md");
-    const latestPath = join20(buildRoot, "latest");
+    const reportPath = join21(runPath, "report.json");
+    const reportMarkdownPath = join21(runPath, "report.md");
+    const latestPath = join21(buildRoot, "latest");
     const activationReport = activationPath === undefined ? {} : {
       activation: {
         path: relative16(rootPath, activationPath),
@@ -21620,8 +21957,8 @@ async function runSkillsetTest(rootPath, name, options = {}) {
       ...activationReport,
       workspacePath: relative16(rootPath, workspacePath)
     };
-    await writeFile11(reportPath, renderValidatedJson(report, relative16(rootPath, reportPath)), "utf8");
-    await writeFile11(reportMarkdownPath, renderMarkdownReport(report), "utf8");
+    await writeFile12(reportPath, renderValidatedJson(report, relative16(rootPath, reportPath)), "utf8");
+    await writeFile12(reportMarkdownPath, renderMarkdownReport(report), "utf8");
     await refreshLatest(buildRoot, runPath, latestPath, report, rootPath);
     return {
       assertions,
@@ -21866,11 +22203,11 @@ function activationExpectationCandidatePaths(graph, target, expect) {
   }
   if (expect.kind === "agent") {
     const projectRoot = targetProjectRoot4(graph, target);
-    return graph.projectAgents.filter((agent) => agent.name === expect.name || agent.outputName === expect.name).map((agent) => join20(projectRoot, "agents", `${agent.outputName}.${target === "claude" ? "md" : "toml"}`));
+    return graph.projectAgents.filter((agent) => agent.name === expect.name || agent.outputName === expect.name).map((agent) => join21(projectRoot, "agents", `${agent.outputName}.${target === "claude" ? "md" : "toml"}`));
   }
   return [
-    ...graph.standaloneSkills.filter((skill) => skill.id === expect.name).map((skill) => join20(graph.root.outputs.skills[target], dirname15(skill.relativePath), "SKILL.md")),
-    ...graph.plugins.flatMap((plugin) => plugin.skills.filter((skill) => skill.id === expect.name).map((skill) => join20(graph.root.outputs.plugins[target], "plugins", plugin.id, dirname15(skill.relativePath), "SKILL.md")))
+    ...graph.standaloneSkills.filter((skill) => skill.id === expect.name).map((skill) => join21(graph.root.outputs.skills[target], dirname16(skill.relativePath), "SKILL.md")),
+    ...graph.plugins.flatMap((plugin) => plugin.skills.filter((skill) => skill.id === expect.name).map((skill) => join21(graph.root.outputs.plugins[target], "plugins", plugin.id, dirname16(skill.relativePath), "SKILL.md")))
   ];
 }
 function targetProjectRoot4(graph, target) {
@@ -21879,22 +22216,22 @@ function targetProjectRoot4(graph, target) {
 async function writeActivationProbes(runPath, declaration) {
   if (declaration.activationProbes.length === 0)
     return;
-  const activationRoot = join20(runPath, "activation");
+  const activationRoot = join21(runPath, "activation");
   for (const target of declaration.targets) {
     const probes = declaration.activationProbes.filter((probe) => probe.targets.includes(target));
     if (probes.length === 0)
       continue;
-    const targetRoot = join20(activationRoot, target);
-    await mkdir10(targetRoot, { recursive: true });
+    const targetRoot = join21(activationRoot, target);
+    await mkdir11(targetRoot, { recursive: true });
     const records = probes.map((probe) => activationProbeRecord(probe, target));
-    await writeFile11(join20(targetRoot, "probes.json"), renderValidatedJson({
+    await writeFile12(join21(targetRoot, "probes.json"), renderValidatedJson({
       probes: records,
       schemaVersion: TEST_SCHEMA,
       target
     }, `activation ${target} probes`), "utf8");
     for (const record of records) {
       const name = typeof record.name === "string" ? record.name : "probe";
-      await writeFile11(join20(targetRoot, `${name}.md`), renderActivationProbeMarkdown(record), "utf8");
+      await writeFile12(join21(targetRoot, `${name}.md`), renderActivationProbeMarkdown(record), "utf8");
     }
   }
   return activationRoot;
@@ -21951,14 +22288,14 @@ async function refreshLatest(buildRoot, runPath, latestPath, report, rootPath) {
   const latest = {
     name: report.name,
     ok: report.ok,
-    reportPath: relative16(rootPath, join20(latestPath, "report.json")),
+    reportPath: relative16(rootPath, join21(latestPath, "report.json")),
     runId: report.runId,
     runPath: relative16(rootPath, runPath),
     schemaVersion: TEST_SCHEMA,
     source: report.source,
-    workspacePath: relative16(rootPath, join20(latestPath, "workspace"))
+    workspacePath: relative16(rootPath, join21(latestPath, "workspace"))
   };
-  await writeFile11(join20(buildRoot, "latest.json"), renderValidatedJson(latest, relative16(rootPath, join20(buildRoot, "latest.json"))), "utf8");
+  await writeFile12(join21(buildRoot, "latest.json"), renderValidatedJson(latest, relative16(rootPath, join21(buildRoot, "latest.json"))), "utf8");
 }
 function renderMarkdownReport(report) {
   const assertions = Array.isArray(report.assertions) ? report.assertions : [];
@@ -21995,7 +22332,7 @@ function activationProbeCount(report) {
 }
 async function pathExists2(path2) {
   try {
-    await stat17(path2);
+    await stat18(path2);
     return true;
   } catch {
     return false;
@@ -22004,8 +22341,21 @@ async function pathExists2(path2) {
 async function copyIfExists(sourcePath, targetPath) {
   if (!await pathExists2(sourcePath))
     return;
-  await mkdir10(dirname15(targetPath), { recursive: true });
-  await cp(sourcePath, targetPath);
+  await mkdir11(dirname16(targetPath), { recursive: true });
+  await cp(sourcePath, targetPath, { recursive: true });
+}
+async function copyTestSource(graph, stagingWorkspacePath) {
+  const ignoredSourceBuildPath = resolveInside(graph.rootPath, sourceBuildRoot(graph.sourceDir));
+  if (graph.sourceDir !== ".") {
+    await cp(graph.sourcePath, join21(stagingWorkspacePath, graph.sourceDir), {
+      filter: (path2) => !isSameOrInside2(ignoredSourceBuildPath, path2),
+      recursive: true
+    });
+    return;
+  }
+  await copyIfExists(graph.rootConfigPath, join21(stagingWorkspacePath, "skillset.yaml"));
+  await copyIfExists(graph.sourceRootPath, join21(stagingWorkspacePath, graph.sourceRoot));
+  await copyIfExists(resolveInside(graph.rootPath, "changes"), join21(stagingWorkspacePath, "changes"));
 }
 async function copyWorkspaceManagedFiles(rootPath, stagingWorkspacePath, workspaceLockPath, sourceDir) {
   if (!await pathExists2(workspaceLockPath))
@@ -22018,7 +22368,7 @@ async function copyWorkspaceManagedFiles(rootPath, stagingWorkspacePath, workspa
   }
   if (!isJsonRecord(lock) || !Array.isArray(lock.items))
     return;
-  const ignoredSourceBuildPath = resolveInside(rootPath, join20(sourceDir, "build"));
+  const ignoredSourceBuildPath = resolveInside(rootPath, sourceBuildRoot(sourceDir));
   for (const item of lock.items) {
     if (!isJsonRecord(item) || !Array.isArray(item.files))
       continue;
@@ -22028,10 +22378,16 @@ async function copyWorkspaceManagedFiles(rootPath, stagingWorkspacePath, workspa
       const sourcePath = resolveInside(rootPath, file);
       if (isSameOrInside2(ignoredSourceBuildPath, sourcePath))
         continue;
-      await copyIfExists(sourcePath, join20(stagingWorkspacePath, file));
+      await copyIfExists(sourcePath, join21(stagingWorkspacePath, file));
     }
   }
 }
+function testBuildRoot(sourceDir) {
+  return sourceDir === "." ? join21(".skillset", TEST_BUILD_DIR) : join21(sourceDir, TEST_BUILD_DIR);
+}
+function sourceBuildRoot(sourceDir) {
+  return sourceDir === "." ? ".skillset/build" : join21(sourceDir, "build");
+}
 function makeRunId(name) {
   const stamp = new Date().toISOString().replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "Z");
   const digest2 = createHash8("sha256").update(`${name}:${stamp}:${randomBytes2(8).toString("hex")}`).digest("hex").slice(0, 8);
@@ -22048,8 +22404,10 @@ function messageFor(error) {
 // apps/skillset/src/cli-core.ts
 var USAGE = [
   "usage: skillset build [--yes|--dry-run] [--updated|--all] [--isolated] [--scope <scope>] [--root <path>] [--source <dir>] [--dist <dir>]",
-  "       skillset <check|diff> [--updated|--all] [--isolated] [--scope <scope>] [--root <path>] [--source <dir>] [--dist <dir>]",
-  "       skillset <lint|list> [--updated|--all] [--scope <scope>] [--root <path>] [--source <dir>] [--dist <dir>]",
+  "       skillset verify [--updated|--all] [--isolated] [--scope <scope>] [--root <path>] [--source <dir>] [--dist <dir>]",
+  "       skillset diff [--updated|--all] [--isolated] [--scope <scope>] [--root <path>] [--source <dir>] [--dist <dir>]",
+  "       skillset <check|lint> [--root <path>] [--source <dir>]",
+  "       skillset list [--updated|--all] [--scope <scope>] [--root <path>] [--source <dir>] [--dist <dir>]",
   "       skillset doctor [--json] [--updated|--all] [--scope <scope>] [--root <path>] [--source <dir>] [--dist <dir>]",
   "       skillset ci [--fix] [--since <ref>] [--report <path>] [--root <path>] [--source <dir>] [--dist <dir>]",
   "       skillset change status [--since <ref>] [--root <path>] [--source <dir>] [--dist <dir>]",
@@ -22075,6 +22433,7 @@ var USAGE = [
   "       skillset adopt <path> [--yes|--dry-run] [--targets claude,codex] [--root <path>]",
   "       skillset init [path] [--yes|--dry-run] [--targets claude,codex] [--include ci] [--name <name>] [--root <path>]",
   "       skillset create [path|--global] [--yes|--dry-run] [--targets claude,codex] [--include ci] [--name <name>] [--root <path>]",
+  "       skillset new <skill|agent|hook> [name] [--id <id>] [--name <name>] [--in <container>] [--scope repo] [--preset <preset>] [--yes|--dry-run] [--root <path>] [--source <dir>]",
   "       skillset explain <path> [--json] [--scope <scope>] [--root <path>] [--source <dir>]",
   "       skillset import <path> [--kind <skill|skills|plugin|plugins>] [--from <provider>] [--name <name>] [--root <path>] [--source <dir>]",
   "       skillset import <claude|codex|agents> [--root <path>] [--source <dir>]"
@@ -22114,6 +22473,12 @@ async function runCli(rawArgs = process.argv.slice(2), invokedName = basename9(p
     importName,
     importProvider,
     jsonOutput,
+    newContainer,
+    newId,
+    newKind,
+    newName,
+    newPresets,
+    newScope,
     options,
     rootPath,
     rootExplicit,
@@ -22156,8 +22521,8 @@ async function runCli(rawArgs = process.argv.slice(2), invokedName = basename9(p
     });
     if (ciReportPath !== undefined) {
       const reportPath = resolve10(ciReportPath);
-      await mkdir11(dirname16(reportPath), { recursive: true });
-      await writeFile12(reportPath, renderCiReportMarkdown(report));
+      await mkdir12(dirname17(reportPath), { recursive: true });
+      await writeFile13(reportPath, renderCiReportMarkdown(report));
     }
     printCiReport(report);
     if (!report.ok)
@@ -22334,6 +22699,16 @@ async function runCli(rawArgs = process.argv.slice(2), invokedName = basename9(p
     console.log(`skillset: linted ${result3.checkedSkills} source skills`);
     return;
   }
+  if (command === "check") {
+    const result3 = await lintSkillset(rootPath, options);
+    for (const issue of result3.issues) {
+      if (issue.severity !== "warn")
+        continue;
+      console.log(`  warn: ${issue.path}: ${issue.code}: ${issue.message}`);
+    }
+    console.log(`skillset: checked ${result3.checkedSkills} source skills`);
+    return;
+  }
   if (command === "adopt") {
     const writeMode = yes && !dryRun;
     const report = await adoptSkillset(importPath === undefined ? rootPath : importPath, {
@@ -22395,6 +22770,25 @@ async function runCli(rawArgs = process.argv.slice(2), invokedName = basename9(p
       console.warn(`  warning: ${warning}`);
     return;
   }
+  if (command === "new") {
+    if (newKind === undefined)
+      throw new Error("skillset: expected new kind skill, agent, or hook");
+    const report = await scaffoldSourceUnit(rootPath, {
+      ...newContainer === undefined ? {} : { container: newContainer },
+      ...newId === undefined ? {} : { id: newId },
+      kind: newKind,
+      ...newName === undefined ? {} : { displayName: newName },
+      ...importPath === undefined ? {} : { name: importPath },
+      ...newPresets === undefined ? {} : { presets: newPresets },
+      ...newScope === undefined ? {} : { scope: newScope },
+      skillsetOptions: options,
+      write: yes && !dryRun
+    });
+    printNewSourceReport(report, dryRun ? "dry run" : yes ? "written" : "write confirmation required");
+    if (!yes || dryRun)
+      console.log("skillset: rerun new with --yes to write source files");
+    return;
+  }
   if (command === "diff") {
     const result3 = await diffSkillsetResult(rootPath, options);
     printDiagnostics(result3.diagnostics);
@@ -22563,9 +22957,9 @@ async function runCli(rawArgs = process.argv.slice(2), invokedName = basename9(p
     }
     return;
   }
-  const result2 = await checkSkillsetResult(rootPath, options);
+  const result2 = await verifySkillsetResult(rootPath, options);
   printDiagnostics(result2.diagnostics);
-  console.log(`skillset: checked ${result2.data.checkedFiles} generated files`);
+  console.log(`skillset: verified ${result2.data.checkedFiles} generated files`);
   if (!result2.ok) {
     console.error(`skillset: generated output is not current`);
     for (const failure of result2.data.failures)
@@ -22930,6 +23324,18 @@ function printSetupReport(result2, reason) {
   console.log(`skillset: ${result2.kind} ${details.join(", ")} (${reason})`);
   console.log(`  root: ${result2.rootPath}`);
 }
+function printNewSourceReport(result2, reason) {
+  for (const file of result2.files)
+    console.log(`  + ${file.path}`);
+  const action = result2.write ? "created" : "planned";
+  console.log(`skillset: ${action} ${result2.kind} ${result2.id} (${reason})`);
+  console.log(`  source: ${result2.sourceRoot}`);
+  console.log(`  name: ${result2.displayName}`);
+  if (result2.write) {
+    console.log("  next: skillset check");
+    console.log("  next: skillset verify");
+  }
+}
 function printRestoreReport(report) {
   const mode = report.write ? "restored" : "restore preview";
   console.log(`skillset: ${mode} ${report.restoredPaths.length} file${report.restoredPaths.length === 1 ? "" : "s"} from backup ${report.runId}`);
@@ -22984,8 +23390,8 @@ function printRenderResult(outcome) {
 }
 function parseArgs(args) {
   const command = args[0];
-  if (command !== "adopt" && command !== "build" && command !== "change" && command !== "check" && command !== "ci" && command !== "create" && command !== "diff" && command !== "distribute" && command !== "doctor" && command !== "explain" && command !== "features" && command !== "hooks" && command !== "import" && command !== "init" && command !== "lint" && command !== "list" && command !== "release" && command !== "restore" && command !== "suggest-source" && command !== "test") {
-    throw new Error(`skillset: expected command adopt, build, change, check, ci, create, diff, distribute, doctor, explain, features, hooks, import, init, lint, list, release, restore, suggest-source, or test
+  if (command !== "adopt" && command !== "build" && command !== "change" && command !== "check" && command !== "ci" && command !== "create" && command !== "diff" && command !== "distribute" && command !== "doctor" && command !== "explain" && command !== "features" && command !== "hooks" && command !== "import" && command !== "init" && command !== "lint" && command !== "list" && command !== "new" && command !== "release" && command !== "restore" && command !== "suggest-source" && command !== "test" && command !== "verify") {
+    throw new Error(`skillset: expected command adopt, build, change, check, ci, create, diff, distribute, doctor, explain, features, hooks, import, init, lint, list, new, release, restore, suggest-source, test, or verify
 ` + USAGE);
   }
   let changeSubcommand;
@@ -23016,6 +23422,12 @@ function parseArgs(args) {
   let importPath;
   let importProvider;
   let jsonOutput = false;
+  let newContainer;
+  let newId;
+  let newKind;
+  let newName;
+  let newPresets;
+  let newScope;
   let rootPath = process.cwd();
   let rootExplicit = false;
   let sourceDir;
@@ -23139,6 +23551,19 @@ function parseArgs(args) {
       index += 1;
     }
   }
+  if (command === "new") {
+    const rawKind = args[index];
+    if (!isNewSourceKind(rawKind)) {
+      throw new Error("skillset: expected new kind skill, agent, or hook");
+    }
+    newKind = rawKind;
+    index += 1;
+    const rawName = args[index];
+    if (rawName !== undefined && !rawName.startsWith("--")) {
+      importPath = rawName;
+      index += 1;
+    }
+  }
   for (;index < args.length; index += 1) {
     const arg = args[index];
     if (arg === undefined)
@@ -23146,7 +23571,7 @@ function parseArgs(args) {
     const equalsIndex = arg.indexOf("=");
     const flag = equalsIndex === -1 ? arg : arg.slice(0, equalsIndex);
     const inlineValue = equalsIndex === -1 ? undefined : arg.slice(equalsIndex + 1);
-    if (flag !== "--root" && flag !== "--source" && flag !== "--dist" && flag !== "--name" && flag !== "--kind" && flag !== "--from" && flag !== "--append" && flag !== "--bump" && flag !== "--group" && flag !== "--reason" && flag !== "--reason-file" && flag !== "--ref" && flag !== "--since" && flag !== "--staged" && flag !== "--yes" && flag !== "--dry-run" && flag !== "--updated" && flag !== "--all" && flag !== "--isolated" && flag !== "--scope" && flag !== "--global" && flag !== "--targets" && flag !== "--include" && flag !== "--fix" && flag !== "--report" && flag !== "--json" && flag !== "--runner" && flag !== "--target" && flag !== "--agent-runtime" && flag !== "--pre-commit" && flag !== "--pre-push" && flag !== "--write") {
+    if (flag !== "--root" && flag !== "--source" && flag !== "--dist" && flag !== "--id" && flag !== "--name" && flag !== "--in" && flag !== "--kind" && flag !== "--from" && flag !== "--preset" && flag !== "--append" && flag !== "--bump" && flag !== "--group" && flag !== "--reason" && flag !== "--reason-file" && flag !== "--ref" && flag !== "--since" && flag !== "--staged" && flag !== "--yes" && flag !== "--dry-run" && flag !== "--updated" && flag !== "--all" && flag !== "--isolated" && flag !== "--scope" && flag !== "--global" && flag !== "--targets" && flag !== "--include" && flag !== "--fix" && flag !== "--report" && flag !== "--json" && flag !== "--runner" && flag !== "--target" && flag !== "--agent-runtime" && flag !== "--pre-commit" && flag !== "--pre-push" && flag !== "--write") {
       throw new Error(`skillset: unknown option ${arg}`);
     }
     if (flag === "--yes" || flag === "--dry-run" || flag === "--updated" || flag === "--all" || flag === "--isolated" || flag === "--append" || flag === "--staged" || flag === "--global" || flag === "--fix" || flag === "--json" || flag === "--agent-runtime" || flag === "--pre-commit" || flag === "--pre-push" || flag === "--write") {
@@ -23211,6 +23636,8 @@ function parseArgs(args) {
         throw new Error(`skillset: change ${changeSubcommand} is a whole-source command; --scope is not supported`);
       } else if (command === "change") {
         throw new Error("skillset: --scope is only supported with change add source-unit entries");
+      } else if (command === "new") {
+        newScope = readNewSourceScope(value);
       } else {
         scopes = readBuildScopes(value);
       }
@@ -23243,8 +23670,18 @@ function parseArgs(args) {
       setupTargets = readSetupTargets(value);
     if (flag === "--include")
       setupIncludes = mergeSetupIncludes(setupIncludes, value);
-    if (flag === "--name")
-      importName = value;
+    if (flag === "--id")
+      newId = value;
+    if (flag === "--in")
+      newContainer = value;
+    if (flag === "--name") {
+      if (command === "new")
+        newName = value;
+      else
+        importName = value;
+    }
+    if (flag === "--preset")
+      newPresets = [...newPresets ?? [], value];
     if (flag === "--kind") {
       if (!isImportKind(value)) {
         throw new Error("skillset: expected --kind skill, skills, plugin, or plugins");
@@ -23307,6 +23744,13 @@ function parseArgs(args) {
     ...scopes === undefined ? {} : { scopes }
   });
   validateJsonFlags(command, jsonOutput);
+  validateSourceDiagnosticFlags(command, {
+    ...buildMode === undefined ? {} : { buildMode },
+    ...distDir === undefined ? {} : { distDir },
+    dryRun,
+    ...scopes === undefined ? {} : { scopes },
+    yes
+  });
   validateIsolatedFlag(command, isolated);
   validateDistributionFlags(command, {
     ...buildMode === undefined ? {} : { buildMode },
@@ -23348,6 +23792,18 @@ function parseArgs(args) {
     write: sourceSuggestionWrite,
     yes
   });
+  validateNewSourceFlags(command, {
+    ...buildMode === undefined ? {} : { buildMode },
+    ...distDir === undefined ? {} : { distDir },
+    ...newContainer === undefined ? {} : { container: newContainer },
+    ...newId === undefined ? {} : { id: newId },
+    ...importKind === undefined ? {} : { importKind },
+    ...importProvider === undefined ? {} : { importProvider },
+    ...newKind === undefined ? {} : { kind: newKind },
+    ...newName === undefined ? {} : { name: newName },
+    ...newPresets === undefined ? {} : { presets: newPresets },
+    ...newScope === undefined ? {} : { scope: newScope }
+  });
   const options = {
     ...buildMode === undefined ? {} : { buildMode },
     ...scopes === undefined ? {} : { scopes },
@@ -23383,6 +23839,12 @@ function parseArgs(args) {
     ...importPath === undefined ? {} : { importPath },
     ...importProvider === undefined ? {} : { importProvider },
     jsonOutput,
+    ...newContainer === undefined ? {} : { newContainer },
+    ...newId === undefined ? {} : { newId },
+    ...newKind === undefined ? {} : { newKind },
+    ...newName === undefined ? {} : { newName },
+    ...newPresets === undefined ? {} : { newPresets },
+    ...newScope === undefined ? {} : { newScope },
     options,
     ...releaseSubcommand === undefined ? {} : { releaseSubcommand },
     ...releaseReason === undefined ? {} : { releaseReason },
@@ -23403,6 +23865,14 @@ function isReleaseSubcommand(value) {
 function isChangeSubcommand(value) {
   return value === "add" || value === "amend" || value === "check" || value === "history" || value === "list" || value === "reason" || value === "show" || value === "status";
 }
+function isNewSourceKind(value) {
+  return value === "agent" || value === "hook" || value === "skill";
+}
+function readNewSourceScope(value) {
+  if (value === "repo")
+    return value;
+  throw new Error("skillset: new currently supports only --scope repo");
+}
 function readChangeScopes(value) {
   const scopes = value.split(",").map((scope) => scope.trim()).filter((scope) => scope.length > 0);
   if (scopes.length === 0)
@@ -23497,6 +23967,23 @@ function validateTestFlags(command, test2) {
     throw new Error("skillset: build/write options are not supported with test; test output always writes under .skillset/build/tests");
   }
 }
+function validateSourceDiagnosticFlags(command, sourceCheck) {
+  if (command !== "check" && command !== "lint")
+    return;
+  const label = `skillset ${command}`;
+  if (sourceCheck.buildMode !== undefined) {
+    throw new Error(`${label} does not support --updated or --all; it checks source diagnostics`);
+  }
+  if (sourceCheck.scopes !== undefined) {
+    throw new Error(`${label} does not support --scope; it checks source diagnostics`);
+  }
+  if (sourceCheck.distDir !== undefined) {
+    throw new Error(`${label} does not support --dist; it checks source diagnostics`);
+  }
+  if (sourceCheck.dryRun || sourceCheck.yes) {
+    throw new Error(`${label} is read-only and does not support --yes or --dry-run`);
+  }
+}
 function validateRestoreFlags(command, restore) {
   if (command !== "restore")
     return;
@@ -23523,6 +24010,24 @@ function validateSuggestSourceFlags(command, suggestion) {
   if (suggestion.write && !suggestion.yes)
     throw new Error("skillset: suggest-source --write requires --yes");
 }
+function validateNewSourceFlags(command, source2) {
+  const hasNewFlag = source2.container !== undefined || source2.id !== undefined || source2.kind !== undefined || source2.name !== undefined || source2.presets !== undefined || source2.scope !== undefined;
+  if (hasNewFlag && command !== "new") {
+    throw new Error("skillset: new options are only supported with new");
+  }
+  if (command !== "new")
+    return;
+  if (source2.buildMode !== undefined)
+    throw new Error("skillset: --updated and --all are not supported with new");
+  if (source2.distDir !== undefined)
+    throw new Error("skillset: --dist is not supported with new");
+  if (source2.importKind !== undefined)
+    throw new Error("skillset: --kind is only supported with import");
+  if (source2.importProvider !== undefined)
+    throw new Error("skillset: --from is only supported with import");
+  if (source2.kind === undefined)
+    throw new Error("skillset: expected new kind skill, agent, or hook");
+}
 function setBuildMode(current, next) {
   if (current !== undefined && current !== next) {
     throw new Error(`skillset: conflicting build mode flags --${current} and --${next}`);
@@ -23589,9 +24094,9 @@ function readSetupTargets(value) {
 function validateIsolatedFlag(command, isolated) {
   if (!isolated)
     return;
-  if (command === "build" || command === "check" || command === "diff")
+  if (command === "build" || command === "diff" || command === "verify")
     return;
-  throw new Error("skillset: --isolated is only supported with build, check, or diff");
+  throw new Error("skillset: --isolated is only supported with build, diff, or verify");
 }
 function validateCiFlags(command, ci) {
   if (command !== "ci") {