skills-package-manager 0.7.0 → 0.8.0

package/README.md

@@ -11,6 +11,8 @@ npx skills-package-manager --help
 npx skills-package-manager --version
 npx skills-package-manager add <specifier> [--skill <name>]
 npx skills-package-manager install
+npx skills-package-manager patch <skill>
+npx skills-package-manager patch-commit <edit-dir>
 npx skills-package-manager update [skill...]
 npx skills-package-manager init [--yes]
 ```
@@ -104,6 +106,40 @@ npx skills-package-manager install
 
 This resolves each skill from its specifier, materializes it into `installDir` (default `.agents/skills/`), and creates symlinks for each `linkTarget`.
 When `selfSkill` is `true`, `npx skills-package-manager install` also installs the bundled `skills-package-manager-cli` skill so users get guidance for `skills.json`, `skills-lock.yaml`, and `npx skills-package-manager` commands. This helper skill is not written to `skills-lock.yaml`.
+If `patchedSkills` contains an entry for a skill, the corresponding patch file is applied after the skill is materialized.
+
+### `npx skills-package-manager patch`
+
+Prepare a skill for patching without changing the manifest yet:
+
+```bash
+npx skills-package-manager patch hello-skill
+npx skills-package-manager patch hello-skill --edit-dir ./tmp/hello-skill
+```
+
+Behavior:
+
+- Resolves the currently locked content for the target skill
+- Extracts an editable copy into a temporary directory by default
+- Reapplies any committed patch for that skill unless `--ignore-existing` is passed
+- Writes patch edit metadata so `patch-commit` can generate a new patch file later
+
+### `npx skills-package-manager patch-commit`
+
+Commit an edited patch directory back into the project:
+
+```bash
+npx skills-package-manager patch-commit /tmp/skills-pm-patch-hello-skill-12345
+npx skills-package-manager patch-commit ./tmp/hello-skill --patches-dir ./custom-patches
+```
+
+Behavior:
+
+- Compares the edited directory with the original resolved skill content
+- Writes a unified diff patch file to `patches/<skill>.patch` by default
+- Updates `skills.json` through the `patchedSkills` field
+- Updates `skills-lock.yaml` with patch path and digest metadata
+- Reinstalls and relinks the patched skill so the working tree reflects the committed patch
 
 ### `npx skills-package-manager update`
 
@@ -172,10 +208,11 @@ link: link:<path-to-skill-dir>
 src/
 ├── bin/           # CLI entry points
 ├── cli/           # CLI runner and interactive prompts
-├── commands/      # add, install command implementations
+├── commands/      # add, install, patch command implementations
 ├── config/        # skills.json / skills-lock.yaml read/write
 ├── github/        # Git clone + skill discovery (listSkills)
 ├── install/       # Skill materialization, linking, pruning
+├── patches/       # Patch edit state, diff generation, patch application
 ├── specifiers/    # Specifier parsing and normalization
 └── utils/         # Hashing, filesystem helpers
 ```

package/dist/index.d.ts

@@ -0,0 +1,466 @@
+export declare function addCommand(options: AddCommandOptions): Promise<{
+    skillName: string;
+    specifier: string;
+} | {
+    skillName: string;
+    specifier: string;
+}[]>;
+
+export declare type AddCommandOptions = {
+    cwd: string;
+    specifier: string;
+    skill?: string;
+    global?: boolean;
+    yes?: boolean;
+    agent?: string[];
+};
+
+/**
+ * Clone a git repo (shallow) into a temp dir, discover skills, then clean up.
+ */
+export declare function cloneAndDiscover(gitUrl: string, ref?: string): Promise<{
+    skills: SkillInfo[];
+    cleanup: () => Promise<void>;
+}>;
+
+/**
+ * Converts a Node.js file system error to an appropriate SPM error type
+ */
+export declare function convertNodeError(error: NodeJS.ErrnoException, context: {
+    operation: string;
+    path: string;
+}): FileSystemError;
+
+export declare function createInstallProgressReporter(options?: ProgressReporterOptions): InstallProgressReporter;
+
+/**
+ * Discover skills in a local directory by scanning for SKILL.md files.
+ * Recursively scans the repo tree for directories containing SKILL.md.
+ */
+export declare function discoverSkillsInDir(baseDir: string): Promise<SkillInfo[]>;
+
+/**
+ * Error codes for SPM (Skills Package Manager)
+ * Inspired by pnpm's error code system
+ */
+export declare enum ErrorCode {
+    FILE_NOT_FOUND = "ENOENT",
+    PERMISSION_DENIED = "EACCES",
+    FILE_EXISTS = "EEXIST",
+    FS_ERROR = "EFS",
+    GIT_CLONE_FAILED = "EGITCLONE",
+    GIT_FETCH_FAILED = "EGITFETCH",
+    GIT_CHECKOUT_FAILED = "EGITCHECKOUT",
+    GIT_REF_NOT_FOUND = "EGITREF",
+    GIT_NOT_INSTALLED = "EGITNOTFOUND",
+    PARSE_ERROR = "EPARSE",
+    JSON_PARSE_ERROR = "EJSONPARSE",
+    YAML_PARSE_ERROR = "EYAMLPARSE",
+    INVALID_SPECIFIER = "EINVALIDSPEC",
+    MANIFEST_NOT_FOUND = "EMANIFEST",
+    LOCKFILE_NOT_FOUND = "ELOCKFILE",
+    LOCKFILE_OUTDATED = "ELOCKOUTDATED",
+    MANIFEST_EXISTS = "EMANIFESTEXISTS",
+    MANIFEST_VALIDATION_ERROR = "EMANIFESTVAL",
+    NETWORK_ERROR = "ENETWORK",
+    REPO_NOT_FOUND = "EREPONOTFOUND",
+    UNKNOWN_ERROR = "EUNKNOWN",
+    NOT_IMPLEMENTED = "ENOTIMPL",
+    VALIDATION_ERROR = "EVALIDATION",
+    SKILL_NOT_FOUND = "ESKILLNOTFOUND",
+    SKILL_EXISTS = "ESKILLEXISTS"
+}
+
+export declare function expandSkillsManifest(_rootDir: string, manifest: SkillsManifest): Promise<NormalizedSkillsManifest>;
+
+export declare function fetchSkillsFromLock(rootDir: string, manifest: SkillsManifest, lockfile: SkillsLock, options?: {
+    onProgress?: InstallProgressListener;
+}): Promise<{
+    readonly status: "skipped";
+    readonly reason: "up-to-date";
+    readonly fetched?: undefined;
+} | {
+    readonly status: "fetched";
+    readonly fetched: string[];
+    readonly reason?: undefined;
+}>;
+
+/**
+ * Error thrown when file system operations fail
+ */
+export declare class FileSystemError extends SpmError {
+    readonly operation: string;
+    readonly path: string;
+    constructor(options: {
+        code: ErrorCode.FILE_NOT_FOUND | ErrorCode.PERMISSION_DENIED | ErrorCode.FILE_EXISTS | ErrorCode.FS_ERROR;
+        operation: 'read' | 'write' | 'access' | 'mkdir' | 'rm' | 'copy' | 'symlink' | string;
+        path: string;
+        message?: string;
+        cause?: Error;
+    });
+}
+
+/**
+ * Formats an error for display to the user
+ * Provides helpful context for known error types
+ */
+export declare function formatErrorForDisplay(error: unknown): string;
+
+/**
+ * Gets the exit code for an error
+ * Returns 1 for general errors, specific codes for known error types
+ */
+export declare function getExitCode(error: unknown): number;
+
+/**
+ * Error thrown when git operations fail
+ */
+export declare class GitError extends SpmError {
+    readonly operation: string;
+    readonly repoUrl?: string;
+    readonly ref?: string;
+    constructor(options: {
+        code: ErrorCode.GIT_CLONE_FAILED | ErrorCode.GIT_FETCH_FAILED | ErrorCode.GIT_CHECKOUT_FAILED | ErrorCode.GIT_REF_NOT_FOUND | ErrorCode.GIT_NOT_INSTALLED;
+        operation: 'clone' | 'fetch' | 'checkout' | 'ls-remote' | 'rev-parse' | string;
+        repoUrl?: string;
+        ref?: string;
+        message?: string;
+        cause?: Error;
+    });
+}
+
+export declare function initCommand(options: InitCommandOptions, promptInit?: InitPrompter): Promise<SkillsManifest>;
+
+export declare type InitCommandOptions = {
+    cwd: string;
+    yes?: boolean;
+};
+
+declare type InitPrompter = () => Promise<InitPromptResult>;
+
+declare type InitPromptResult = {
+    installDir: string;
+    linkTargets: string[];
+};
+
+export declare function installCommand(options: InstallCommandOptions): Promise<{
+    readonly status: "installed";
+    readonly installed: string[];
+}>;
+
+export declare type InstallCommandOptions = {
+    cwd: string;
+    frozenLockfile?: boolean;
+};
+
+declare type InstallPhase = 'resolving' | 'fetching' | 'linking' | 'finalizing' | 'done';
+
+export declare type InstallProgressEvent = {
+    type: 'resolved';
+    skillName: string;
+} | {
+    type: 'added';
+    skillName: string;
+} | {
+    type: 'installed';
+    skillName: string;
+};
+
+export declare type InstallProgressListener = (event: InstallProgressEvent) => void;
+
+declare type InstallProgressReporter = {
+    start(total: number): void;
+    setPhase(phase: Exclude<InstallPhase, 'done'>): void;
+    onProgress(event: InstallProgressEvent): void;
+    complete(): void;
+    fail(): void;
+};
+
+export declare function installSkills(rootDir: string, options?: {
+    frozenLockfile?: boolean;
+    onProgress?: InstallProgressListener;
+}): Promise<{
+    readonly status: "skipped";
+    readonly reason: "manifest-missing";
+    readonly installed?: undefined;
+} | {
+    readonly status: "installed";
+    readonly installed: string[];
+    readonly reason?: undefined;
+}>;
+
+export declare const installStageHooks: {
+    beforeFetch: (_rootDir: string, _manifest: SkillsManifest, _lockfile: SkillsLock) => Promise<void>;
+};
+
+export declare function isLockInSync(rootDir: string, manifest: NormalizedSkillsManifest, lock: SkillsLock | null): Promise<boolean>;
+
+/**
+ * Checks if an error is a known SPM error
+ */
+export declare function isSpmError(error: unknown): error is SpmError;
+
+export declare function linkSkillsFromLock(rootDir: string, manifest: SkillsManifest, lockfile: SkillsLock, options?: {
+    onProgress?: InstallProgressListener;
+}): Promise<{
+    readonly status: "linked";
+    readonly linked: string[];
+}>;
+
+/**
+ * List skills in a GitHub repo by cloning and scanning.
+ * This avoids GitHub API rate limits.
+ */
+export declare function listRepoSkills(owner: string, repo: string, ref?: string): Promise<SkillInfo[]>;
+
+/**
+ * Error thrown when manifest or lockfile operations fail
+ */
+export declare class ManifestError extends SpmError {
+    readonly filePath: string;
+    constructor(options: {
+        code: ErrorCode.MANIFEST_NOT_FOUND | ErrorCode.LOCKFILE_NOT_FOUND | ErrorCode.LOCKFILE_OUTDATED | ErrorCode.MANIFEST_EXISTS | ErrorCode.MANIFEST_VALIDATION_ERROR;
+        filePath: string;
+        message?: string;
+        cause?: Error;
+    });
+}
+
+/**
+ * Error thrown when network operations fail
+ */
+export declare class NetworkError extends SpmError {
+    readonly url?: string;
+    constructor(options: {
+        code: ErrorCode.NETWORK_ERROR | ErrorCode.REPO_NOT_FOUND;
+        url?: string;
+        message: string;
+        cause?: Error;
+    });
+}
+
+/**
+ * Skills manifest output type after validation/default application.
+ * Use this for normalized manifests returned from reads/parsing.
+ */
+declare type NormalizedSkillsManifest = {
+    $schema?: string;
+    installDir: string;
+    linkTargets: string[];
+    selfSkill?: boolean;
+    skills: Record<string, string>;
+    patchedSkills?: Record<string, string>;
+};
+
+export declare type NormalizedSpecifier = {
+    type: 'git' | 'link' | 'file' | 'npm';
+    source: string;
+    ref: string | null;
+    path: string;
+    normalized: string;
+    skillName: string;
+};
+
+export declare function normalizeSkillsManifest(manifest: Partial<SkillsManifest>): NormalizedSkillsManifest;
+
+export declare function normalizeSpecifier(specifier: string): NormalizedSpecifier;
+
+/**
+ * Error thrown when parsing fails (JSON, YAML, specifiers)
+ */
+export declare class ParseError extends SpmError {
+    readonly filePath?: string;
+    readonly content?: string;
+    constructor(options: {
+        code: ErrorCode.PARSE_ERROR | ErrorCode.JSON_PARSE_ERROR | ErrorCode.YAML_PARSE_ERROR | ErrorCode.INVALID_SPECIFIER;
+        filePath?: string;
+        content?: string;
+        message: string;
+        cause?: Error;
+    });
+}
+
+export declare function parseGitHubUrl(input: string): {
+    owner: string;
+    repo: string;
+} | null;
+
+export declare function parseOwnerRepo(input: string): {
+    owner: string;
+    repo: string;
+} | null;
+
+export declare function parseSpecifier(specifier: string): {
+    sourcePart: string;
+    ref: string | null;
+    path: string;
+};
+
+export declare function patchCommand(options: PatchCommandOptions): Promise<PatchCommandResult>;
+
+export declare type PatchCommandOptions = {
+    cwd: string;
+    skillName: string;
+    editDir?: string;
+    ignoreExisting?: boolean;
+};
+
+export declare type PatchCommandResult = {
+    status: 'patched';
+    skillName: string;
+    editDir: string;
+    originalSpecifier: string;
+};
+
+export declare function patchCommitCommand(options: PatchCommitCommandOptions): Promise<PatchCommitCommandResult>;
+
+export declare type PatchCommitCommandOptions = {
+    cwd: string;
+    editDir: string;
+    patchesDir?: string;
+};
+
+export declare type PatchCommitCommandResult = {
+    status: 'patched';
+    skillName: string;
+    patchFile: string;
+};
+
+declare type ProgressReporterOptions = {
+    isTTY?: boolean;
+    write?: (text: string) => void;
+    info?: (text: string) => void;
+};
+
+export declare function readSkillsLock(rootDir: string): Promise<SkillsLock | null>;
+
+export declare function readSkillsManifest(rootDir: string): Promise<NormalizedSkillsManifest | null>;
+
+export declare function resolveLockEntry(cwd: string, specifier: string, skillName?: string): Promise<{
+    skillName: string;
+    entry: SkillsLockEntry;
+}>;
+
+export declare function runCli(argv: string[], context?: {
+    cwd?: string;
+}): Promise<unknown>;
+
+/**
+ * Error thrown when a skill operation fails
+ */
+export declare class SkillError extends SpmError {
+    readonly skillName: string;
+    constructor(options: {
+        code: ErrorCode.SKILL_NOT_FOUND | ErrorCode.SKILL_EXISTS | ErrorCode.VALIDATION_ERROR;
+        skillName: string;
+        message?: string;
+        cause?: Error;
+    });
+}
+
+export declare type SkillInfo = {
+    name: string;
+    description: string;
+    path: string;
+};
+
+export declare type SkillsLock = {
+    lockfileVersion: '0.1';
+    installDir: string;
+    linkTargets: string[];
+    skills: Record<string, SkillsLockEntry>;
+};
+
+export declare type SkillsLockEntry = {
+    specifier: string;
+    resolution: {
+        type: 'link';
+        path: string;
+    } | {
+        type: 'file';
+        tarball: string;
+        path: string;
+    } | {
+        type: 'git';
+        url: string;
+        commit: string;
+        path: string;
+    } | {
+        type: 'npm';
+        packageName: string;
+        version: string;
+        path: string;
+        tarball: string;
+        integrity?: string;
+        registry?: string;
+    };
+    digest: string;
+    patch?: {
+        path: string;
+        digest: string;
+    };
+};
+
+/**
+ * Skills manifest input type used for authoring/writing manifests.
+ * This preserves optionality for fields with defaults.
+ */
+export declare type SkillsManifest = {
+    $schema?: string;
+    installDir?: string;
+    linkTargets?: string[];
+    selfSkill?: boolean;
+    skills?: Record<string, string>;
+    patchedSkills?: Record<string, string>;
+};
+
+/**
+ * Base error class for SPM (Skills Package Manager)
+ * All custom errors should extend this class
+ */
+export declare class SpmError extends Error {
+    readonly code: ErrorCode;
+    readonly cause?: Error;
+    readonly context: Record<string, unknown>;
+    constructor(options: {
+        code: ErrorCode;
+        message: string;
+        cause?: Error;
+        context?: Record<string, unknown>;
+    });
+    /**
+     * Returns a formatted string representation of the error
+     */
+    toString(): string;
+    /**
+     * Returns a detailed object representation for logging/debugging
+     */
+    toJSON(): Record<string, unknown>;
+}
+
+export declare function updateCommand(options: UpdateCommandOptions): Promise<UpdateCommandResult>;
+
+export declare type UpdateCommandOptions = {
+    cwd: string;
+    skills?: string[];
+};
+
+export declare type UpdateCommandResult = {
+    status: 'updated' | 'skipped' | 'failed';
+    updated: string[];
+    unchanged: string[];
+    skipped: Array<{
+        name: string;
+        reason: 'link-specifier';
+    }>;
+    failed: Array<{
+        name: string;
+        reason: string;
+    }>;
+};
+
+export declare function writeSkillsLock(rootDir: string, lockfile: SkillsLock): Promise<void>;
+
+export declare function writeSkillsManifest(rootDir: string, manifest: SkillsManifest): Promise<void>;
+
+export { }

package/dist/index.js

@@ -16,7 +16,7 @@ import { co } from "./npm-tar.js";
 import { cac } from "./npm-cac.js";
 import { Ct } from "./npm-clack_core.js";
 var package_namespaceObject = {
-    rE: "0.7.0"
+    rE: "0.8.0"
 };
 function getHomeDir() {
     return homedir();
@@ -721,7 +721,8 @@ const skillsManifestSchema = schemas_object({
     installDir: schemas_string().default('.agents/skills').describe('Directory where skills will be installed'),
     linkTargets: schemas_array(schemas_string()).default([]).describe('Directories where skill symlinks will be created'),
     selfSkill: schemas_boolean().optional().describe('Whether this project is itself a skill'),
-    skills: record(schemas_string(), schemas_string()).default({}).describe('Map of skill names to their specifiers')
+    skills: record(schemas_string(), schemas_string()).default({}).describe('Map of skill names to their specifiers'),
+    patchedSkills: record(schemas_string(), schemas_string()).optional().describe('Map of skill names to their patch file paths')
 }).strict();
 async function readSkillsManifest(rootDir) {
     const filePath = node_path.join(rootDir, 'skills.json');
@@ -1093,11 +1094,11 @@ async function sha256File(filePath, suffix = '') {
     if (suffix) hash.update(suffix);
     return `sha256-${hash.digest('hex')}`;
 }
-const execFileAsync = promisify(execFile);
 function toPortableRelativePath(from, to) {
     const relativePath = node_path.relative(from, to) || '.';
     return '/' === node_path.sep ? relativePath : relativePath.split(node_path.sep).join('/');
 }
+const execFileAsync = promisify(execFile);
 async function resolveGitCommitByLsRemote(url, target) {
     try {
         const { stdout } = await execFileAsync('git', [
@@ -1247,16 +1248,29 @@ async function resolveLockEntry(cwd, specifier, skillName) {
         content: specifier
     });
 }
+async function attachManifestPatchToEntry(cwd, manifest, skillName, entry) {
+    const patchPath = manifest.patchedSkills?.[skillName];
+    if (!patchPath) return entry;
+    const absolutePatchPath = node_path.resolve(cwd, patchPath);
+    return {
+        ...entry,
+        patch: {
+            path: toPortableRelativePath(cwd, absolutePatchPath),
+            digest: await sha256File(absolutePatchPath)
+        }
+    };
+}
 async function syncSkillsLock(cwd, manifest, _existingLock, options) {
     const entries = await Promise.all(Object.entries(manifest.skills).map(async ([skillName, specifier])=>{
         const { skillName: resolvedName, entry } = await resolveLockEntry(cwd, specifier, skillName);
+        const entryWithPatch = await attachManifestPatchToEntry(cwd, manifest, resolvedName, entry);
         options?.onProgress?.({
             type: 'resolved',
             skillName: resolvedName
         });
         return [
             resolvedName,
-            entry
+            entryWithPatch
         ];
     }));
     const nextSkills = Object.fromEntries(entries);
@@ -1288,6 +1302,7 @@ async function writeSkillsManifest(rootDir, manifest) {
         skills: manifest.skills
     };
     if (void 0 !== manifest.selfSkill) nextManifest.selfSkill = manifest.selfSkill;
+    if (manifest.patchedSkills && Object.keys(manifest.patchedSkills).length > 0) nextManifest.patchedSkills = manifest.patchedSkills;
     try {
         await writeFile(filePath, `${JSON.stringify(nextManifest, null, 2)}\n`, 'utf8');
     } catch (error) {
@@ -1470,17 +1485,31 @@ function arraysEqual(a, b) {
     if (a.length !== b.length) return false;
     return a.every((val, i)=>val === b[i]);
 }
-function isLockInSync(manifest, lock) {
+async function isPatchInSync(rootDir, manifest, skillName, lock) {
+    const lockEntry = lock.skills[skillName];
+    if (!lockEntry) return false;
+    const manifestPatchPath = manifest.patchedSkills?.[skillName];
+    if (!manifestPatchPath) return void 0 === lockEntry.patch;
+    if (!lockEntry.patch) return false;
+    const absolutePatchPath = node_path.resolve(rootDir, manifestPatchPath);
+    const normalizedPatchPath = toPortableRelativePath(rootDir, absolutePatchPath);
+    if (lockEntry.patch.path !== normalizedPatchPath) return false;
+    return lockEntry.patch.digest === await sha256File(absolutePatchPath);
+}
+async function isLockInSync(rootDir, manifest, lock) {
     if (!lock) return false;
     if (normalizeInstallDir(manifest.installDir) !== normalizeInstallDir(lock.installDir)) return false;
     if (!arraysEqual(normalizeLinkTargets(manifest.linkTargets), normalizeLinkTargets(lock.linkTargets))) return false;
     const manifestSkills = Object.entries(manifest.skills);
     const lockSkillNames = Object.keys(lock.skills);
+    const patchedSkillNames = Object.keys(manifest.patchedSkills ?? {});
     if (manifestSkills.length !== lockSkillNames.length) return false;
+    if (patchedSkillNames.some((skillName)=>!(skillName in manifest.skills))) return false;
     for (const [name, specifier] of manifestSkills){
         const lockEntry = lock.skills[name];
         if (!lockEntry) return false;
         if (!isSpecifierCompatible(specifier, lockEntry.specifier)) return false;
+        if (!await isPatchInSync(rootDir, manifest, name, lock)) return false;
     }
     return true;
 }
@@ -1522,7 +1551,8 @@ function normalizeSkillsManifest(manifest) {
         installDir: manifest.installDir ?? '.agents/skills',
         linkTargets: manifest.linkTargets ?? [],
         selfSkill: manifest.selfSkill ?? false,
-        skills: manifest.skills ?? {}
+        skills: manifest.skills ?? {},
+        patchedSkills: manifest.patchedSkills
     };
 }
 async function expandSkillsManifest(_rootDir, manifest) {
@@ -1538,6 +1568,172 @@ async function expandSkillsManifest(_rootDir, manifest) {
         }
     };
 }
+const skillPatch_execFileAsync = promisify(execFile);
+const PATCH_EDIT_STATE_FILE = '.skills-pm-patch.json';
+async function writePatchEditState(editDir, state) {
+    const filePath = node_path.join(editDir, PATCH_EDIT_STATE_FILE);
+    await writeFile(filePath, `${JSON.stringify(state, null, 2)}\n`, 'utf8');
+}
+async function readPatchEditState(editDir) {
+    const filePath = node_path.join(editDir, PATCH_EDIT_STATE_FILE);
+    let raw;
+    try {
+        raw = await readFile(filePath, 'utf8');
+    } catch (error) {
+        throw convertNodeError(error, {
+            operation: 'read',
+            path: filePath
+        });
+    }
+    try {
+        return JSON.parse(raw);
+    } catch (error) {
+        throw new ParseError({
+            code: codes_ErrorCode.JSON_PARSE_ERROR,
+            filePath,
+            content: raw,
+            message: `Failed to parse patch edit state: ${error.message}`,
+            cause: error
+        });
+    }
+}
+async function clearDirectoryExceptGit(rootDir) {
+    const entries = await readdir(rootDir, {
+        withFileTypes: true
+    });
+    await Promise.all(entries.filter((entry)=>'.git' !== entry.name).map((entry)=>rm(node_path.join(rootDir, entry.name), {
+            recursive: true,
+            force: true
+        })));
+}
+async function copySkillDir(from, to) {
+    await cp(from, to, {
+        recursive: true,
+        filter: (source)=>{
+            const baseName = node_path.basename(source);
+            return baseName !== PATCH_EDIT_STATE_FILE && '.git' !== baseName && '.hg' !== baseName;
+        }
+    });
+}
+async function runGitCommand(args, options) {
+    try {
+        return await skillPatch_execFileAsync('git', args, {
+            cwd: options.cwd,
+            ...options.maxBuffer ? {
+                maxBuffer: options.maxBuffer
+            } : {}
+        });
+    } catch (error) {
+        const nodeError = error;
+        if ('ENOENT' === nodeError.code) throw new GitError({
+            code: codes_ErrorCode.GIT_NOT_INSTALLED,
+            operation: options.operation,
+            message: 'git is required to create and apply skill patches',
+            cause: error
+        });
+        throw new GitError({
+            code: codes_ErrorCode.GIT_FETCH_FAILED,
+            operation: options.operation,
+            message: options.message,
+            cause: error
+        });
+    }
+}
+async function applySkillPatch(targetDir, patchFilePath) {
+    try {
+        await access(patchFilePath);
+    } catch (error) {
+        throw convertNodeError(error, {
+            operation: 'read',
+            path: patchFilePath
+        });
+    }
+    await runGitCommand([
+        'apply',
+        '--whitespace=nowarn',
+        patchFilePath
+    ], {
+        cwd: targetDir,
+        operation: 'apply',
+        message: `Failed to apply patch ${patchFilePath}`
+    });
+}
+async function generateSkillPatch(baseDir, editedDir) {
+    const repoRoot = await mkdtemp(node_path.join(tmpdir(), 'skills-pm-patch-commit-'));
+    try {
+        await runGitCommand([
+            'init',
+            '--quiet'
+        ], {
+            cwd: repoRoot,
+            operation: 'init',
+            message: 'Failed to initialize git repository for patch generation'
+        });
+        await runGitCommand([
+            'config',
+            'user.email',
+            'skills-package-manager@example.com'
+        ], {
+            cwd: repoRoot,
+            operation: 'config',
+            message: 'Failed to configure git user email for patch generation'
+        });
+        await runGitCommand([
+            'config',
+            'user.name',
+            'skills-package-manager'
+        ], {
+            cwd: repoRoot,
+            operation: 'config',
+            message: 'Failed to configure git user name for patch generation'
+        });
+        await copySkillDir(baseDir, repoRoot);
+        await runGitCommand([
+            'add',
+            '--all'
+        ], {
+            cwd: repoRoot,
+            operation: 'add',
+            message: 'Failed to stage base skill files for patch generation'
+        });
+        await runGitCommand([
+            'commit',
+            '--quiet',
+            '--allow-empty',
+            '--no-gpg-sign',
+            '-m',
+            'base'
+        ], {
+            cwd: repoRoot,
+            operation: 'commit',
+            message: 'Failed to create base commit for patch generation'
+        });
+        await clearDirectoryExceptGit(repoRoot);
+        await copySkillDir(editedDir, repoRoot);
+        const { stdout } = await runGitCommand([
+            'diff',
+            '--binary',
+            '--full-index',
+            '--no-ext-diff',
+            '--src-prefix=a/',
+            '--dst-prefix=b/',
+            'HEAD',
+            '--',
+            '.'
+        ], {
+            cwd: repoRoot,
+            operation: 'diff',
+            message: 'Failed to generate skill patch',
+            maxBuffer: 10485760
+        });
+        return stdout;
+    } finally{
+        await rm(repoRoot, {
+            recursive: true,
+            force: true
+        }).catch(()=>{});
+    }
+}
 async function ensureDir(dirPath) {
     await mkdir(dirPath, {
         recursive: true
@@ -1586,7 +1782,7 @@ async function linkSkill(rootDir, installDir, linkTarget, skillName) {
     await ensureDir(node_path.dirname(absoluteLink));
     await replaceSymlink(absoluteTarget, absoluteLink);
 }
-async function materializeLocalSkill(rootDir, skillName, sourceRoot, sourcePath, installDir) {
+async function copyLocalSkillToDir(sourceRoot, sourcePath, targetDir) {
     const relativeSkillPath = sourcePath.replace(/^\//, '');
     const absoluteSkillPath = node_path.join(sourceRoot, relativeSkillPath);
     const skillDocPath = node_path.join(absoluteSkillPath, 'SKILL.md');
@@ -1597,15 +1793,21 @@ async function materializeLocalSkill(rootDir, skillName, sourceRoot, sourcePath,
         throw new Error(`Invalid skill at ${absoluteSkillPath}: missing SKILL.md`);
     }
     if (!skillDoc) throw new Error(`Invalid skill at ${absoluteSkillPath}: missing SKILL.md`);
-    const targetDir = node_path.join(rootDir, installDir, skillName);
     await ensureDir(node_path.dirname(targetDir));
     await replaceDir(absoluteSkillPath, targetDir);
+}
+async function writeInstalledSkillMarker(targetDir, skillName) {
     await writeJson(node_path.join(targetDir, '.skills-pm.json'), {
         name: skillName,
         installedBy: 'skills-package-manager',
         version: '0.1.0'
     });
 }
+async function materializeLocalSkill(rootDir, skillName, sourceRoot, sourcePath, installDir) {
+    const targetDir = node_path.join(rootDir, installDir, skillName);
+    await copyLocalSkillToDir(sourceRoot, sourcePath, targetDir);
+    await writeInstalledSkillMarker(targetDir, skillName);
+}
 const materializeGitSkill_execFileAsync = promisify(execFile);
 async function checkoutCommit(checkoutRoot, commit) {
     try {
@@ -1665,7 +1867,7 @@ async function fetchCommitFallback(checkoutRoot, commit, _repoUrl) {
         });
     }
 }
-async function materializeGitSkill(rootDir, skillName, repoUrl, commit, sourcePath, installDir) {
+async function extractGitSkillToDir(repoUrl, commit, sourcePath, targetDir) {
     const checkoutRoot = await mkdtemp(node_path.join(tmpdir(), 'skills-pm-git-checkout-'));
     try {
         try {
@@ -1698,7 +1900,7 @@ async function materializeGitSkill(rootDir, skillName, repoUrl, commit, sourcePa
         }
         const skillDocPath = node_path.join(checkoutRoot, sourcePath.replace(/^\//, ''), 'SKILL.md');
         await readFile(skillDocPath, 'utf8');
-        await materializeLocalSkill(rootDir, skillName, checkoutRoot, sourcePath, installDir);
+        await copyLocalSkillToDir(checkoutRoot, sourcePath, targetDir);
     } finally{
         await rm(checkoutRoot, {
             recursive: true,
@@ -1706,7 +1908,12 @@ async function materializeGitSkill(rootDir, skillName, repoUrl, commit, sourcePa
         });
     }
 }
-async function materializePackedSkill(rootDir, skillName, tarballPath, sourcePath, installDir) {
+async function materializeGitSkill(rootDir, skillName, repoUrl, commit, sourcePath, installDir) {
+    const targetDir = node_path.join(rootDir, installDir, skillName);
+    await extractGitSkillToDir(repoUrl, commit, sourcePath, targetDir);
+    await writeInstalledSkillMarker(targetDir, skillName);
+}
+async function extractPackedSkillToDir(tarballPath, sourcePath, targetDir) {
     const extractRoot = await mkdtemp(node_path.join(tmpdir(), 'skills-pm-packed-skill-'));
     try {
         await mkdir(node_path.join(extractRoot, 'package'), {
@@ -1719,7 +1926,7 @@ async function materializePackedSkill(rootDir, skillName, tarballPath, sourcePat
             preservePaths: false,
             strict: true
         });
-        await materializeLocalSkill(rootDir, skillName, node_path.join(extractRoot, 'package'), sourcePath, installDir);
+        await copyLocalSkillToDir(node_path.join(extractRoot, 'package'), sourcePath, targetDir);
     } finally{
         await rm(extractRoot, {
             recursive: true,
@@ -1727,6 +1934,11 @@ async function materializePackedSkill(rootDir, skillName, tarballPath, sourcePat
         }).catch(()=>{});
     }
 }
+async function materializePackedSkill(rootDir, skillName, tarballPath, sourcePath, installDir) {
+    const targetDir = node_path.join(rootDir, installDir, skillName);
+    await extractPackedSkillToDir(tarballPath, sourcePath, targetDir);
+    await writeInstalledSkillMarker(targetDir, skillName);
+}
 function pruneManagedSkills_resolveTargetPath(rootDir, targetPath) {
     return node_path.isAbsolute(targetPath) ? targetPath : node_path.join(rootDir, targetPath);
 }
@@ -1805,6 +2017,7 @@ async function fetchSkillsFromLock(rootDir, manifest, lockfile, options) {
         for (const [skillName, entry] of Object.entries(lockfile.skills)){
             if ('link' === entry.resolution.type) {
                 await materializeLocalSkill(rootDir, skillName, node_path.resolve(rootDir, entry.resolution.path), '/', installDir);
+                if (entry.patch) await applySkillPatch(node_path.join(rootDir, installDir, skillName), node_path.resolve(rootDir, entry.patch.path));
                 options?.onProgress?.({
                     type: 'added',
                     skillName
@@ -1813,6 +2026,7 @@ async function fetchSkillsFromLock(rootDir, manifest, lockfile, options) {
             }
             if ('file' === entry.resolution.type) {
                 await materializePackedSkill(rootDir, skillName, node_path.resolve(rootDir, entry.resolution.tarball), entry.resolution.path, installDir);
+                if (entry.patch) await applySkillPatch(node_path.join(rootDir, installDir, skillName), node_path.resolve(rootDir, entry.patch.path));
                 options?.onProgress?.({
                     type: 'added',
                     skillName
@@ -1821,6 +2035,7 @@ async function fetchSkillsFromLock(rootDir, manifest, lockfile, options) {
             }
             if ('git' === entry.resolution.type) {
                 await materializeGitSkill(rootDir, skillName, entry.resolution.url, entry.resolution.commit, entry.resolution.path, installDir);
+                if (entry.patch) await applySkillPatch(node_path.join(rootDir, installDir, skillName), node_path.resolve(rootDir, entry.patch.path));
                 options?.onProgress?.({
                     type: 'added',
                     skillName
@@ -1836,13 +2051,14 @@ async function fetchSkillsFromLock(rootDir, manifest, lockfile, options) {
                 }
                 const tarballPath = await tarballPathPromise;
                 await materializePackedSkill(rootDir, skillName, tarballPath, entry.resolution.path, installDir);
+                if (entry.patch) await applySkillPatch(node_path.join(rootDir, installDir, skillName), node_path.resolve(rootDir, entry.patch.path));
                 options?.onProgress?.({
                     type: 'added',
                     skillName
                 });
                 continue;
             }
-            throw new Error(`Unsupported resolution type in 0.1.0 core flow: ${entry.resolution.type}`);
+            throw new Error('Unsupported resolution type in 0.1.0 core flow');
         }
         await writeInstallState(rootDir, installDir, {
             lockDigest,
@@ -1888,7 +2104,7 @@ async function installSkills(rootDir, options) {
     let lockfile;
     if (options?.frozenLockfile) {
         if (!currentLock) throw new Error('Lockfile is required in frozen mode but none was found');
-        if (!isLockInSync(manifest, currentLock)) throw new Error('Lockfile is out of sync with manifest. Run install without --frozen-lockfile to update.');
+        if (!await isLockInSync(rootDir, manifest, currentLock)) throw new Error('Lockfile is out of sync with manifest. Run install without --frozen-lockfile to update.');
         lockfile = currentLock;
         for (const skillName of Object.keys(lockfile.skills))options?.onProgress?.({
             type: 'resolved',
@@ -2500,7 +2716,7 @@ async function installCommand(options) {
                 filePath: `${options.cwd}/skills-lock.yaml`,
                 message: 'Lockfile is required in frozen mode but none was found. Run "spm install" first.'
             });
-            if (!isLockInSync(manifest, currentLock)) throw new ManifestError({
+            if (!await isLockInSync(options.cwd, manifest, currentLock)) throw new ManifestError({
                 code: codes_ErrorCode.LOCKFILE_OUTDATED,
                 filePath: `${options.cwd}/skills-lock.yaml`,
                 message: 'Lockfile is out of sync with manifest. Run install without --frozen-lockfile to update.'
@@ -2536,6 +2752,193 @@ async function installCommand(options) {
         throw error;
     }
 }
+async function extractSkillToDir(rootDir, entry, targetDir) {
+    if ('link' === entry.resolution.type) return void await copyLocalSkillToDir(node_path.resolve(rootDir, entry.resolution.path), '/', targetDir);
+    if ('file' === entry.resolution.type) return void await extractPackedSkillToDir(node_path.resolve(rootDir, entry.resolution.tarball), entry.resolution.path, targetDir);
+    if ('git' === entry.resolution.type) return void await extractGitSkillToDir(entry.resolution.url, entry.resolution.commit, entry.resolution.path, targetDir);
+    if ('npm' === entry.resolution.type) {
+        const tarballPath = await downloadNpmPackageTarball(rootDir, entry.resolution.tarball, entry.resolution.integrity);
+        try {
+            await extractPackedSkillToDir(tarballPath, entry.resolution.path, targetDir);
+        } finally{
+            await cleanupPackedNpmPackage(tarballPath);
+        }
+        return;
+    }
+    throw new Error('Unsupported resolution type in 0.1.0 core flow');
+}
+async function ensureEditDirDoesNotExist(editDir) {
+    try {
+        await access(editDir);
+    } catch (error) {
+        if ('ENOENT' === error.code) return;
+        throw convertNodeError(error, {
+            operation: 'access',
+            path: editDir
+        });
+    }
+    throw new FileSystemError({
+        code: codes_ErrorCode.FILE_EXISTS,
+        operation: 'mkdir',
+        path: editDir,
+        message: `Patch edit directory already exists: ${editDir}`
+    });
+}
+async function createBaseLock(cwd, manifest, currentLock) {
+    if (currentLock && await isLockInSync(cwd, manifest, currentLock)) return {
+        ...currentLock,
+        skills: {
+            ...currentLock.skills
+        }
+    };
+    return syncSkillsLock(cwd, manifest, currentLock);
+}
+function getUnpatchedBaseEntry(entry) {
+    if (!entry.patch) return entry;
+    const { patch: _patch, ...baseEntry } = entry;
+    return baseEntry;
+}
+async function resolveEditDir(cwd, skillName, editDir) {
+    if (editDir) return node_path.resolve(cwd, editDir);
+    const sanitizedSkillName = skillName.replace(/[^a-zA-Z0-9._-]+/g, '-');
+    return mkdtemp(node_path.join(tmpdir(), `skills-pm-patch-${sanitizedSkillName}-`));
+}
+async function patchCommand(options) {
+    const manifest = await readSkillsManifest(options.cwd);
+    if (!manifest) throw new ManifestError({
+        code: codes_ErrorCode.MANIFEST_NOT_FOUND,
+        filePath: `${options.cwd}/skills.json`,
+        message: 'No skills.json found in the current directory. Run "spm init" to create one.'
+    });
+    if (!(options.skillName in manifest.skills)) throw new SkillError({
+        code: codes_ErrorCode.SKILL_NOT_FOUND,
+        skillName: options.skillName,
+        message: `Unknown skill: ${options.skillName}`
+    });
+    const currentLock = await readSkillsLock(options.cwd);
+    const baseLock = await createBaseLock(options.cwd, manifest, currentLock);
+    const currentEntry = baseLock.skills[options.skillName];
+    if (!currentEntry) throw new SkillError({
+        code: codes_ErrorCode.SKILL_NOT_FOUND,
+        skillName: options.skillName,
+        message: `Skill "${options.skillName}" is missing from the resolved lockfile state`
+    });
+    const editDir = await resolveEditDir(options.cwd, options.skillName, options.editDir);
+    if (options.editDir) await ensureEditDirDoesNotExist(editDir);
+    const baseEntry = getUnpatchedBaseEntry(currentEntry);
+    await extractSkillToDir(options.cwd, baseEntry, editDir);
+    const existingPatchPath = manifest.patchedSkills?.[options.skillName];
+    if (existingPatchPath && !options.ignoreExisting) await applySkillPatch(editDir, node_path.resolve(options.cwd, existingPatchPath));
+    await writePatchEditState(editDir, {
+        version: 1,
+        skillName: options.skillName,
+        originalSpecifier: manifest.skills[options.skillName],
+        baseEntry
+    });
+    console.info(editDir);
+    return {
+        status: 'patched',
+        skillName: options.skillName,
+        editDir,
+        originalSpecifier: manifest.skills[options.skillName]
+    };
+}
+async function patchCommit_createBaseLock(cwd, manifest, currentLock) {
+    if (currentLock && await isLockInSync(cwd, manifest, currentLock)) return {
+        ...currentLock,
+        skills: {
+            ...currentLock.skills
+        }
+    };
+    return syncSkillsLock(cwd, manifest, currentLock);
+}
+function resolvePatchFilePath(cwd, skillName, existingPatchPath, patchesDir) {
+    if (patchesDir) return node_path.resolve(cwd, patchesDir, `${skillName}.patch`);
+    if (existingPatchPath) return node_path.resolve(cwd, existingPatchPath);
+    return node_path.resolve(cwd, 'patches', `${skillName}.patch`);
+}
+async function patchCommitCommand(options) {
+    const manifest = await readSkillsManifest(options.cwd);
+    if (!manifest) throw new ManifestError({
+        code: codes_ErrorCode.MANIFEST_NOT_FOUND,
+        filePath: `${options.cwd}/skills.json`,
+        message: 'No skills.json found in the current directory. Run "spm init" to create one.'
+    });
+    const editDir = node_path.resolve(options.cwd, options.editDir);
+    const editState = await readPatchEditState(editDir);
+    if (!(editState.skillName in manifest.skills)) throw new SkillError({
+        code: codes_ErrorCode.SKILL_NOT_FOUND,
+        skillName: editState.skillName,
+        message: `Unknown skill: ${editState.skillName}`
+    });
+    if (manifest.skills[editState.skillName] !== editState.originalSpecifier) throw new SkillError({
+        code: codes_ErrorCode.VALIDATION_ERROR,
+        skillName: editState.skillName,
+        message: `Skill "${editState.skillName}" changed since "spm patch" created ${editDir}`
+    });
+    const baseDir = await mkdtemp(node_path.join(tmpdir(), `skills-pm-patch-base-${editState.skillName}-`));
+    try {
+        await extractSkillToDir(options.cwd, editState.baseEntry, baseDir);
+        const patchContent = await generateSkillPatch(baseDir, editDir);
+        if (!patchContent.trim()) throw new SkillError({
+            code: codes_ErrorCode.VALIDATION_ERROR,
+            skillName: editState.skillName,
+            message: `No changes found in ${editDir}`
+        });
+        const patchFilePath = resolvePatchFilePath(options.cwd, editState.skillName, manifest.patchedSkills?.[editState.skillName], options.patchesDir);
+        await mkdir(node_path.dirname(patchFilePath), {
+            recursive: true
+        });
+        await writeFile(patchFilePath, patchContent, 'utf8');
+        const relativePatchPath = toPortableRelativePath(options.cwd, patchFilePath);
+        const nextManifest = {
+            ...manifest,
+            patchedSkills: {
+                ...manifest.patchedSkills ?? {},
+                [editState.skillName]: relativePatchPath
+            }
+        };
+        const currentLock = await readSkillsLock(options.cwd);
+        const baseLock = await patchCommit_createBaseLock(options.cwd, manifest, currentLock);
+        const patchedEntry = await attachManifestPatchToEntry(options.cwd, nextManifest, editState.skillName, editState.baseEntry);
+        const nextLock = {
+            ...baseLock,
+            installDir: nextManifest.installDir ?? '.agents/skills',
+            linkTargets: nextManifest.linkTargets ?? [],
+            skills: {
+                ...baseLock.skills,
+                [editState.skillName]: patchedEntry
+            }
+        };
+        const runtimeLock = await withBundledSelfSkillLock(options.cwd, nextManifest, nextLock);
+        await fetchSkillsFromLock(options.cwd, nextManifest, runtimeLock);
+        await linkSkillsFromLock(options.cwd, nextManifest, runtimeLock);
+        await writeSkillsManifest(options.cwd, nextManifest);
+        await writeSkillsLock(options.cwd, nextLock);
+        console.info(relativePatchPath);
+        return {
+            status: 'patched',
+            skillName: editState.skillName,
+            patchFile: patchFilePath
+        };
+    } finally{
+        await rm(baseDir, {
+            recursive: true,
+            force: true
+        }).catch(()=>{});
+    }
+}
+function normalizeValue(value) {
+    if (Array.isArray(value)) return value.map((item)=>normalizeValue(item));
+    if (value && 'object' == typeof value) return Object.fromEntries(Object.entries(value).sort(([leftKey], [rightKey])=>leftKey.localeCompare(rightKey)).map(([key, nestedValue])=>[
+            key,
+            normalizeValue(nestedValue)
+        ]));
+    return value;
+}
+function stableStringify(value) {
+    return JSON.stringify(normalizeValue(value));
+}
 function createEmptyResult() {
     return {
         status: 'skipped',
@@ -2545,7 +2948,7 @@ function createEmptyResult() {
         failed: []
     };
 }
-function createBaseLock(_cwd, currentLock) {
+function update_createBaseLock(_cwd, currentLock) {
     if (currentLock) return {
         ...currentLock,
         skills: {
@@ -2574,7 +2977,7 @@ async function updateCommand(options) {
         message: `Unknown skill: ${skillName}`
     });
     const result = createEmptyResult();
-    const candidateLock = createBaseLock(options.cwd, currentLock);
+    const candidateLock = update_createBaseLock(options.cwd, currentLock);
     candidateLock.installDir = manifest.installDir ?? '.agents/skills';
     candidateLock.linkTargets = manifest.linkTargets ?? [];
     for (const skillName of targetSkills){
@@ -2589,20 +2992,13 @@ async function updateCommand(options) {
                 continue;
             }
             const { entry } = await resolveLockEntry(options.cwd, specifier);
+            const nextEntry = await attachManifestPatchToEntry(options.cwd, manifest, skillName, entry);
             const previous = currentLock?.skills[skillName];
-            if (previous?.resolution.type === 'git' && 'git' === entry.resolution.type && previous.specifier === entry.specifier && previous.resolution.url === entry.resolution.url && previous.resolution.commit === entry.resolution.commit && previous.resolution.path === entry.resolution.path) {
+            if (previous && stableStringify(previous) === stableStringify(nextEntry)) {
                 result.unchanged.push(skillName);
                 continue;
             }
-            if (previous?.resolution.type === 'npm' && 'npm' === entry.resolution.type && previous.specifier === entry.specifier && previous.resolution.packageName === entry.resolution.packageName && previous.resolution.version === entry.resolution.version && previous.resolution.path === entry.resolution.path && previous.resolution.tarball === entry.resolution.tarball && previous.resolution.integrity === entry.resolution.integrity && previous.resolution.registry === entry.resolution.registry) {
-                result.unchanged.push(skillName);
-                continue;
-            }
-            if (previous?.resolution.type === 'file' && 'file' === entry.resolution.type && previous.specifier === entry.specifier && previous.digest === entry.digest) {
-                result.unchanged.push(skillName);
-                continue;
-            }
-            candidateLock.skills[skillName] = entry;
+            candidateLock.skills[skillName] = nextEntry;
             result.updated.push(skillName);
         } catch (error) {
             result.failed.push({
@@ -2626,6 +3022,8 @@ function createHandlers(overrides) {
     return {
         addCommand: addCommand,
         installCommand: installCommand,
+        patchCommitCommand: patchCommitCommand,
+        patchCommand: patchCommand,
         updateCommand: updateCommand,
         initCommand: initCommand,
         ...overrides
@@ -2661,6 +3059,17 @@ async function runCli(argv, context = {}) {
             cwd,
             frozenLockfile: options.frozenLockfile
         }));
+    cli.command('patch <skill>').option('--edit-dir <dir>', 'Directory to extract the editable skill into').option('--ignore-existing', 'Ignore an existing committed patch while preparing the edit dir').action(async (skill, options)=>handlers.patchCommand({
+            cwd,
+            skillName: skill,
+            editDir: options.editDir,
+            ignoreExisting: options.ignoreExisting
+        }));
+    cli.command('patch-commit <editDir>').option('--patches-dir <dir>', 'Directory to save the generated patch file into').action(async (editDir, options)=>handlers.patchCommitCommand({
+            cwd,
+            editDir,
+            patchesDir: options.patchesDir
+        }));
     cli.command('update [...skills]').action(async (skills = [])=>handlers.updateCommand({
             cwd,
             skills: skills.length > 0 ? skills : void 0
@@ -2696,4 +3105,4 @@ async function runCli(argv, context = {}) {
         throw error;
     }
 }
-export { FileSystemError, GitError, ManifestError, NetworkError, ParseError, SkillError, SpmError, addCommand, cloneAndDiscover, codes_ErrorCode as ErrorCode, convertNodeError, createInstallProgressReporter, discoverSkillsInDir, expandSkillsManifest, fetchSkillsFromLock, formatErrorForDisplay, getExitCode, initCommand, installCommand, installSkills, installStageHooks, isLockInSync, isSpmError, linkSkillsFromLock, listRepoSkills, normalizeSkillsManifest, normalizeSpecifier, parseGitHubUrl, parseOwnerRepo, parseSpecifier, readSkillsLock, readSkillsManifest, resolveLockEntry, runCli, updateCommand, writeSkillsLock, writeSkillsManifest };
+export { FileSystemError, GitError, ManifestError, NetworkError, ParseError, SkillError, SpmError, addCommand, cloneAndDiscover, codes_ErrorCode as ErrorCode, convertNodeError, createInstallProgressReporter, discoverSkillsInDir, expandSkillsManifest, fetchSkillsFromLock, formatErrorForDisplay, getExitCode, initCommand, installCommand, installSkills, installStageHooks, isLockInSync, isSpmError, linkSkillsFromLock, listRepoSkills, normalizeSkillsManifest, normalizeSpecifier, parseGitHubUrl, parseOwnerRepo, parseSpecifier, patchCommand, patchCommitCommand, readSkillsLock, readSkillsManifest, resolveLockEntry, runCli, updateCommand, writeSkillsLock, writeSkillsManifest };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skills-package-manager",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "type": "module",
   "repository": {
     "type": "git",
@@ -20,10 +20,12 @@
     "skills.schema.json"
   ],
   "devDependencies": {
+    "@microsoft/api-extractor": "^7.58.5",
     "@clack/prompts": "^1.1.0",
     "cac": "^7.0.0",
     "picocolors": "^1.1.1",
     "semver": "^7.7.2",
+    "@types/semver": "^7.7.1",
     "tar": "^7.4.3",
     "yaml": "^2.8.1",
     "zod": "^4.3.6",

package/skills.schema.json

@@ -33,6 +33,16 @@
       "additionalProperties": {
         "type": "string"
       }
+    },
+    "patchedSkills": {
+      "description": "Map of skill names to their patch file paths",
+      "type": "object",
+      "propertyNames": {
+        "type": "string"
+      },
+      "additionalProperties": {
+        "type": "string"
+      }
     }
   },
   "required": [