@workbench-ai/workbench 0.0.73 → 0.0.75

package/dist/install-targets.d.ts

@@ -1,35 +1,68 @@
 import { type Json, type SurfaceSnapshotFile } from "@workbench-ai/workbench-core";
-export type WorkbenchInstallAgentTarget = "codex" | "claude";
-export type WorkbenchInstallTargetName = WorkbenchInstallAgentTarget | "local";
+type StoreKind = "machine" | "local";
 export interface WorkbenchInstallSnapshot {
     name: string;
     files: SurfaceSnapshotFile[];
 }
-export interface WorkbenchInstallTarget {
-    agent: WorkbenchInstallTargetName;
-    mode: "copy";
-    destination: string;
+export interface WorkbenchInstallProvenanceInput {
+    handle: string;
+    versionId: string;
+    baseUrl: string;
 }
-export interface WorkbenchInstallTargetResult extends WorkbenchInstallTarget {
-    previous: "none" | "overwritten" | "unchanged";
+export interface WorkbenchInstallProvenanceRecord extends WorkbenchInstallProvenanceInput {
+    installedAt: string;
+    contentHash: string;
 }
-export interface WorkbenchInstallResult {
-    result: "installed" | "unchanged";
-    targets: WorkbenchInstallTargetResult[];
+export interface WorkbenchInstallStoreResult {
+    result: "installed" | "planned" | "unchanged";
+    store: StoreKind;
+    directoryName: string;
+    destination: string;
+    previous: "none" | "overwritten" | "unchanged";
     filesCopied: number;
+    contentHash: string;
+    provenancePath: string;
+}
+export type WorkbenchInstalledSkillStatus = "current" | "update" | "modified" | "unmanaged";
+export interface WorkbenchInstalledSkill {
+    store: StoreKind;
+    storeRoot: string;
+    name: string;
+    directoryName: string;
+    description?: string;
+    path: string;
+    versionId?: string;
+    handle?: string;
+    baseUrl?: string;
+    installedAt?: string;
+    contentHash: string;
+    status: WorkbenchInstalledSkillStatus;
+    latestVersionId?: string;
+}
+export interface WorkbenchInstalledInventory {
+    stores: Array<{
+        kind: StoreKind;
+        path: string;
+    }>;
+    skills: WorkbenchInstalledSkill[];
+    next: string | null;
 }
-export declare function supportedInstallTargets(): WorkbenchInstallTarget[];
-export declare function resolveInstallTargets(options: {
-    agents: readonly string[];
-    local: boolean;
-    skillName: string;
-}): WorkbenchInstallTarget[];
-export declare function installSnapshotToTargets(options: {
+export declare function canonicalSkillsStore(): string;
+export declare function provenancePathForStore(storeRoot?: string): string;
+export declare function installSnapshotToStore(options: {
     snapshot: WorkbenchInstallSnapshot;
-    targets: readonly WorkbenchInstallTarget[];
     overwrite: boolean;
     dryRun: boolean;
-}): Promise<WorkbenchInstallResult>;
+    provenance: WorkbenchInstallProvenanceInput;
+    installedAt?: string;
+}): Promise<WorkbenchInstallStoreResult>;
+export declare function canonicalSkillDirectoryName(snapshot: WorkbenchInstallSnapshot): string;
+export declare function readInstalledSkillsInventory(options?: {
+    cwd?: string;
+    includeUpdates?: boolean;
+    lookupLatestVersion?: (record: WorkbenchInstallProvenanceRecord) => Promise<string | undefined>;
+}): Promise<WorkbenchInstalledInventory>;
+export declare function installedInventoryToJson(inventory: WorkbenchInstalledInventory): Record<string, Json>;
 export declare function normalizeInstallSnapshotPath(filePath: string): string;
-export declare function installTargetsToJson(targets: readonly WorkbenchInstallTarget[]): Json[];
+export {};
 //# sourceMappingURL=install-targets.d.ts.map

package/dist/install-targets.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"install-targets.d.ts","sourceRoot":"","sources":["../src/install-targets.ts"],"names":[],"mappings":"AAIA,OAAO,EAAuB,KAAK,IAAI,EAAE,KAAK,mBAAmB,EAAE,MAAM,8BAA8B,CAAC;AAExG,MAAM,MAAM,2BAA2B,GAAG,OAAO,GAAG,QAAQ,CAAC;AAC7D,MAAM,MAAM,0BAA0B,GAAG,2BAA2B,GAAG,OAAO,CAAC;AAE/E,MAAM,WAAW,wBAAwB;IACvC,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,mBAAmB,EAAE,CAAC;CAC9B;AAED,MAAM,WAAW,sBAAsB;IACrC,KAAK,EAAE,0BAA0B,CAAC;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,4BAA6B,SAAQ,sBAAsB;IAC1E,QAAQ,EAAE,MAAM,GAAG,aAAa,GAAG,WAAW,CAAC;CAChD;AAED,MAAM,WAAW,sBAAsB;IACrC,MAAM,EAAE,WAAW,GAAG,WAAW,CAAC;IAClC,OAAO,EAAE,4BAA4B,EAAE,CAAC;IACxC,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,wBAAgB,uBAAuB,IAAI,sBAAsB,EAAE,CAMlE;AAED,wBAAgB,qBAAqB,CAAC,OAAO,EAAE;IAC7C,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1B,KAAK,EAAE,OAAO,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB,GAAG,sBAAsB,EAAE,CA8B3B;AAED,wBAAsB,wBAAwB,CAAC,OAAO,EAAE;IACtD,QAAQ,EAAE,wBAAwB,CAAC;IACnC,OAAO,EAAE,SAAS,sBAAsB,EAAE,CAAC;IAC3C,SAAS,EAAE,OAAO,CAAC;IACnB,MAAM,EAAE,OAAO,CAAC;CACjB,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAyDlC;AAiBD,wBAAgB,4BAA4B,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAgBrE;AAyDD,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,SAAS,sBAAsB,EAAE,GAAG,IAAI,EAAE,CAMvF"}
+{"version":3,"file":"install-targets.d.ts","sourceRoot":"","sources":["../src/install-targets.ts"],"names":[],"mappings":"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"}

package/dist/install-targets.js

@@ -1,115 +1,126 @@
 import { promises as fs } from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { WorkbenchCodedError } from "@workbench-ai/workbench-core";
-export function supportedInstallTargets() {
-    return [
-        { agent: "codex", mode: "copy", destination: path.join(workbenchAgentHome("codex"), "skills", "<skill>") },
-        { agent: "claude", mode: "copy", destination: path.join(workbenchAgentHome("claude"), "skills", "<skill>") },
-        { agent: "local", mode: "copy", destination: path.join(process.cwd(), ".agents", "skills", "<skill>") },
-    ];
+import { hashJson, WorkbenchCodedError } from "@workbench-ai/workbench-core";
+import YAML from "yaml";
+const PROVENANCE_SCHEMA = "workbench.provenance.v1";
+const PROVENANCE_FILE = ".workbench-provenance.json";
+export function canonicalSkillsStore() {
+    return path.join(homeDirectory(), ".agents", "skills");
 }
-export function resolveInstallTargets(options) {
-    const targets = [];
-    for (const rawAgent of options.agents) {
-        const agent = rawAgent.trim().toLowerCase();
-        if (agent !== "codex" && agent !== "claude") {
-            throw new WorkbenchCodedError("usage", `Unsupported install agent: ${rawAgent}`, {
-                remediation: "Use --to codex, --to claude, or --to local.",
-                exitCode: 2,
-            });
-        }
-        targets.push({
-            agent,
-            mode: "copy",
-            destination: path.join(workbenchAgentHome(agent), "skills", options.skillName),
-        });
-    }
-    if (options.local) {
-        targets.push({
-            agent: "local",
-            mode: "copy",
-            destination: path.join(process.cwd(), ".agents", "skills", options.skillName),
-        });
-    }
-    if (targets.length === 0) {
-        throw new WorkbenchCodedError("install_target_required", "workbench install requires an explicit target.", {
-            remediation: "Run workbench install OWNER/SKILL --to codex, workbench install OWNER/SKILL --to claude, or workbench install OWNER/SKILL --to local.",
-            exitCode: 2,
-        });
-    }
-    return dedupeTargets(targets);
+export function provenancePathForStore(storeRoot = canonicalSkillsStore()) {
+    return path.join(storeRoot, PROVENANCE_FILE);
 }
-export async function installSnapshotToTargets(options) {
+export async function installSnapshotToStore(options) {
+    const skillName = canonicalSkillDirectoryName(options.snapshot);
+    const destination = path.join(canonicalSkillsStore(), skillName);
     const normalizedFiles = options.snapshot.files.map((file) => ({
         ...file,
         path: normalizeInstallSnapshotPath(file.path),
     }));
-    const next = new Map(normalizedFiles.map((file) => [file.path, installFileContent(file)]));
-    // Pre-validate every target before mutating any destination so a conflict
-    // on a later target cannot leave an earlier target partially installed.
-    const plan = [];
-    for (const target of options.targets) {
-        const existing = await readExistingTree(target.destination).catch((error) => {
-            const code = error.code;
-            if (code === "ENOENT") {
-                return null;
-            }
-            if (code === "ENOTDIR") {
-                const conflictPath = error.path ?? target.destination;
-                throw new WorkbenchCodedError("install_failed", `Install target path is blocked by an existing file: ${conflictPath}`, {
-                    remediation: `Remove the conflicting file ${conflictPath} and rerun the install.`,
-                    subject: { destination: target.destination, conflictPath },
-                    exitCode: 1,
-                });
-            }
-            throw error;
-        });
-        const identical = existing ? fileMapsEqual(existing, next) : false;
-        if (identical) {
-            plan.push({ target, previous: "unchanged" });
-            continue;
+    const contentHash = contentHashForFiles(normalizedFiles);
+    const existingHash = await readExistingTreeHash(destination).catch((error) => {
+        const code = error.code;
+        if (code === "ENOENT") {
+            return null;
         }
-        if (existing && !options.overwrite) {
-            throw new WorkbenchCodedError("install_failed", `Install target already exists: ${target.destination}`, {
-                remediation: "Pass --yes to overwrite the existing target.",
-                subject: { destination: target.destination },
+        if (code === "ENOTDIR") {
+            const conflictPath = error.path ?? destination;
+            throw new WorkbenchCodedError("install_failed", `Canonical skill path is blocked by an existing file: ${conflictPath}`, {
+                remediation: `Remove the conflicting file ${conflictPath} and rerun the install.`,
+                subject: { destination, conflictPath },
                 exitCode: 1,
             });
         }
-        plan.push({ target, previous: existing ? "overwritten" : "none" });
+        throw error;
+    });
+    const previous = existingHash
+        ? existingHash === contentHash ? "unchanged" : "overwritten"
+        : "none";
+    if (existingHash && previous !== "unchanged" && !options.overwrite) {
+        throw new WorkbenchCodedError("install_failed", `Canonical skill already exists: ${destination}`, {
+            remediation: "Pass --yes to overwrite the existing canonical store skill.",
+            subject: { destination },
+            exitCode: 1,
+        });
     }
-    let filesCopied = 0;
-    const results = [];
-    for (const entry of plan) {
-        results.push({ ...entry.target, previous: entry.previous });
-        if (entry.previous === "unchanged") {
-            continue;
-        }
-        filesCopied += normalizedFiles.length;
-        if (!options.dryRun) {
-            await fs.rm(entry.target.destination, { recursive: true, force: true });
-            await writeSnapshotFiles(entry.target.destination, normalizedFiles);
-        }
+    if (!options.dryRun && previous !== "unchanged") {
+        await fs.rm(destination, { recursive: true, force: true });
+        await writeSnapshotFiles(destination, normalizedFiles);
+    }
+    if (!options.dryRun) {
+        await writeProvenanceRecord(canonicalSkillsStore(), skillName, {
+            ...options.provenance,
+            installedAt: options.installedAt ?? new Date().toISOString(),
+            contentHash,
+        });
     }
     return {
-        result: plan.some((entry) => entry.previous !== "unchanged") ? "installed" : "unchanged",
-        targets: results,
-        filesCopied,
+        result: previous === "unchanged" ? "unchanged" : options.dryRun ? "planned" : "installed",
+        store: "machine",
+        directoryName: skillName,
+        destination,
+        previous,
+        filesCopied: previous === "unchanged" ? 0 : normalizedFiles.length,
+        contentHash,
+        provenancePath: provenancePathForStore(),
     };
 }
-function workbenchAgentHome(agent) {
-    if (agent === "codex") {
-        return process.env.CODEX_HOME?.trim() || path.join(os.homedir(), ".codex");
+export function canonicalSkillDirectoryName(snapshot) {
+    const skillFile = snapshot.files.find((file) => normalizeInstallSnapshotPath(file.path) === "SKILL.md");
+    if (skillFile && skillFile.encoding !== "base64") {
+        const metadata = parseSkillMetadata(skillFile.content);
+        if (metadata.name && isValidStoreDirectoryName(metadata.name)) {
+            return metadata.name;
+        }
     }
-    return process.env.CLAUDE_HOME?.trim() || path.join(os.homedir(), ".claude");
+    return installStoreSkillDirectoryName(snapshot.name);
+}
+function isValidStoreDirectoryName(value) {
+    return value.length > 0 &&
+        !value.includes("\0") &&
+        !value.includes("/") &&
+        !value.includes("\\") &&
+        value !== "." &&
+        value !== "..";
 }
-function dedupeTargets(targets) {
-    const byDestination = new Map();
-    for (const target of targets) {
-        byDestination.set(target.destination, target);
+export async function readInstalledSkillsInventory(options = {}) {
+    const stores = await installedSkillStores(options.cwd ?? process.cwd());
+    const skills = [];
+    for (const store of stores) {
+        skills.push(...await readStoreInventory(store, options));
     }
-    return [...byDestination.values()];
+    skills.sort((left, right) => left.name.localeCompare(right.name) || left.store.localeCompare(right.store) || left.path.localeCompare(right.path));
+    const next = skills.find((skill) => skill.status === "update" && skill.handle)?.handle;
+    return {
+        stores,
+        skills,
+        next: next ? `workbench install ${next}` : skills.length === 0 ? "workbench install OWNER/SKILL" : null,
+    };
+}
+export function installedInventoryToJson(inventory) {
+    return {
+        stores: inventory.stores.map((store) => ({
+            kind: store.kind,
+            path: store.path,
+        })),
+        skills: inventory.skills.map((skill) => ({
+            store: skill.store,
+            storeRoot: skill.storeRoot,
+            name: skill.name,
+            directoryName: skill.directoryName,
+            ...(skill.description ? { description: skill.description } : {}),
+            path: skill.path,
+            status: skill.status,
+            contentHash: skill.contentHash,
+            ...(skill.versionId ? { versionId: skill.versionId } : {}),
+            ...(skill.latestVersionId ? { latestVersionId: skill.latestVersionId } : {}),
+            ...(skill.handle ? { handle: skill.handle } : {}),
+            ...(skill.baseUrl ? { baseUrl: skill.baseUrl } : {}),
+            ...(skill.installedAt ? { installedAt: skill.installedAt } : {}),
+        })),
+        next: inventory.next,
+    };
 }
 export function normalizeInstallSnapshotPath(filePath) {
     const normalized = filePath.replace(/\\/gu, "/");
@@ -128,11 +139,218 @@ export function normalizeInstallSnapshotPath(filePath) {
     }
     return normalized;
 }
+async function installedSkillStores(cwd) {
+    const machine = canonicalSkillsStore();
+    const local = path.join(cwd, ".agents", "skills");
+    if (await sameFilesystemPath(local, machine) || !await directoryExists(local)) {
+        return [{ kind: "machine", path: machine }];
+    }
+    return [
+        { kind: "machine", path: machine },
+        { kind: "local", path: local },
+    ];
+}
+async function directoryExists(filePath) {
+    return await fs.stat(filePath).then((stat) => stat.isDirectory(), () => false);
+}
+async function sameFilesystemPath(left, right) {
+    const [leftResolved, rightResolved] = await Promise.all([
+        realpathOrResolved(left),
+        realpathOrResolved(right),
+    ]);
+    return leftResolved === rightResolved;
+}
+async function realpathOrResolved(filePath) {
+    try {
+        return await fs.realpath(filePath);
+    }
+    catch {
+        try {
+            return path.join(await fs.realpath(path.dirname(filePath)), path.basename(filePath));
+        }
+        catch {
+            return path.resolve(filePath);
+        }
+    }
+}
+async function readStoreInventory(store, options) {
+    const provenance = await readProvenanceFile(store.path);
+    let entries;
+    try {
+        entries = await fs.readdir(store.path, { withFileTypes: true });
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === "ENOENT" || code === "ENOTDIR") {
+            return [];
+        }
+        throw error;
+    }
+    const rows = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory() || entry.name.startsWith(".")) {
+            continue;
+        }
+        const skillPath = path.join(store.path, entry.name);
+        const skillFile = path.join(skillPath, "SKILL.md");
+        const skillMarkdown = await fs.readFile(skillFile, "utf8").catch((error) => {
+            if (error.code === "ENOENT") {
+                return null;
+            }
+            throw error;
+        });
+        if (skillMarkdown === null) {
+            continue;
+        }
+        const metadata = parseSkillMetadata(skillMarkdown);
+        const contentHash = await readExistingTreeHash(skillPath);
+        const record = validProvenanceRecord(provenance.skills[entry.name]);
+        const base = {
+            store: store.kind,
+            storeRoot: store.path,
+            name: metadata.name ?? entry.name,
+            directoryName: entry.name,
+            ...(metadata.description ? { description: metadata.description } : {}),
+            path: skillPath,
+            contentHash,
+            status: "unmanaged",
+        };
+        if (!record) {
+            rows.push(base);
+            continue;
+        }
+        let status = contentHash === record.contentHash ? "current" : "modified";
+        let latestVersionId;
+        if (status === "current" && options.includeUpdates === true && options.lookupLatestVersion) {
+            latestVersionId = await options.lookupLatestVersion(record).catch(() => undefined);
+            if (latestVersionId && latestVersionId !== record.versionId) {
+                status = "update";
+            }
+        }
+        rows.push({
+            ...base,
+            status,
+            versionId: record.versionId,
+            handle: record.handle,
+            baseUrl: record.baseUrl,
+            installedAt: record.installedAt,
+            ...(latestVersionId ? { latestVersionId } : {}),
+        });
+    }
+    return rows;
+}
+function parseSkillMetadata(markdown) {
+    if (!markdown.startsWith("---\n") && !markdown.startsWith("---\r\n")) {
+        return {};
+    }
+    const newline = markdown.startsWith("---\r\n") ? "\r\n" : "\n";
+    const closing = markdown.indexOf(`${newline}---${newline}`, 3);
+    if (closing === -1) {
+        return {};
+    }
+    const source = markdown.slice(3 + newline.length, closing);
+    try {
+        const parsed = YAML.parse(source);
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+            return {};
+        }
+        const record = parsed;
+        return {
+            ...(typeof record.name === "string" && record.name.trim() ? { name: record.name.trim() } : {}),
+            ...(typeof record.description === "string" && record.description.trim() ? { description: record.description.trim() } : {}),
+        };
+    }
+    catch {
+        return {};
+    }
+}
+function validProvenanceRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return null;
+    }
+    const record = value;
+    const handle = typeof record.handle === "string" ? record.handle : "";
+    const versionId = typeof record.versionId === "string" ? record.versionId : "";
+    const baseUrl = typeof record.baseUrl === "string" ? record.baseUrl : "";
+    const installedAt = typeof record.installedAt === "string" ? record.installedAt : "";
+    const contentHash = typeof record.contentHash === "string" ? record.contentHash : "";
+    return handle && versionId && baseUrl && installedAt && contentHash
+        ? { handle, versionId, baseUrl, installedAt, contentHash }
+        : null;
+}
+async function writeProvenanceRecord(storeRoot, skillName, record) {
+    const provenance = await readProvenanceFile(storeRoot);
+    for (const key of Object.keys(provenance.skills)) {
+        if (key !== skillName && !await pathExists(path.join(storeRoot, key))) {
+            delete provenance.skills[key];
+        }
+    }
+    provenance.skills[skillName] = record;
+    await fs.mkdir(storeRoot, { recursive: true });
+    const filePath = provenancePathForStore(storeRoot);
+    const tempPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+    await fs.writeFile(tempPath, `${JSON.stringify(provenance, null, 2)}\n`);
+    await fs.rename(tempPath, filePath);
+}
+async function readProvenanceFile(storeRoot) {
+    const filePath = provenancePathForStore(storeRoot);
+    try {
+        const parsed = JSON.parse(await fs.readFile(filePath, "utf8"));
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+            return emptyProvenance();
+        }
+        const record = parsed;
+        if (record.schema !== PROVENANCE_SCHEMA || !record.skills || typeof record.skills !== "object" || Array.isArray(record.skills)) {
+            return emptyProvenance();
+        }
+        return {
+            schema: PROVENANCE_SCHEMA,
+            skills: Object.fromEntries(Object.entries(record.skills).flatMap(([key, value]) => {
+                const valid = validProvenanceRecord(value);
+                return valid ? [[key, valid]] : [];
+            })),
+        };
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return emptyProvenance();
+        }
+        return emptyProvenance();
+    }
+}
+function emptyProvenance() {
+    return {
+        schema: PROVENANCE_SCHEMA,
+        skills: {},
+    };
+}
+function installStoreSkillDirectoryName(skillName) {
+    const normalized = skillName.trim();
+    if (!normalized ||
+        normalized.includes("\0") ||
+        normalized.includes("/") ||
+        normalized.includes("\\") ||
+        normalized === "." ||
+        normalized === "..") {
+        throw new WorkbenchCodedError("install_failed", `Invalid skill name for install store: ${skillName}`, {
+            subject: { skillName },
+            exitCode: 1,
+        });
+    }
+    return normalized;
+}
+function contentHashForFiles(files) {
+    return hashJson(files.map((file) => ({
+        path: normalizeInstallSnapshotPath(file.path),
+        executable: file.executable === true,
+        contentBase64: installFileContent(file).toString("base64"),
+    })).sort((left, right) => left.path.localeCompare(right.path)));
+}
 function installFileContent(file) {
     if (file.encoding === "base64") {
         return Buffer.from(file.content, "base64");
     }
-    return file.content;
+    return Buffer.from(file.content);
 }
 async function writeSnapshotFiles(root, files) {
     for (const file of files) {
@@ -144,45 +362,42 @@ async function writeSnapshotFiles(root, files) {
         }
     }
 }
-async function readExistingTree(root) {
-    const result = new Map();
-    await readExistingTreeInto(root, "", result);
-    return result;
+async function readExistingTreeHash(root) {
+    const files = new Map();
+    const executable = new Map();
+    await readExistingTreeInto(root, "", files, executable);
+    return hashJson([...files.entries()].map(([filePath, content]) => ({
+        path: filePath,
+        executable: executable.get(filePath) === true,
+        contentBase64: content.toString("base64"),
+    })).sort((left, right) => left.path.localeCompare(right.path)));
 }
-async function readExistingTreeInto(root, relativeDir, result) {
+async function readExistingTreeInto(root, relativeDir, result, executable) {
     const dir = path.join(root, relativeDir);
     const entries = await fs.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
         const relativePath = relativeDir ? path.join(relativeDir, entry.name) : entry.name;
         const fullPath = path.join(root, relativePath);
         if (entry.isDirectory()) {
-            await readExistingTreeInto(root, relativePath, result);
+            await readExistingTreeInto(root, relativePath, result, executable);
         }
         else if (entry.isFile()) {
-            result.set(relativePath.replace(/\\/gu, "/"), await fs.readFile(fullPath));
+            const stat = await fs.stat(fullPath);
+            const normalized = relativePath.replace(/\\/gu, "/");
+            result.set(normalized, await fs.readFile(fullPath));
+            executable.set(normalized, (stat.mode & 0o111) !== 0);
         }
     }
 }
-function fileMapsEqual(left, right) {
-    if (left.size !== right.size) {
-        return false;
+async function pathExists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
     }
-    for (const [key, rightValue] of right) {
-        const leftValue = left.get(key);
-        if (!leftValue) {
-            return false;
-        }
-        const rightBuffer = Buffer.isBuffer(rightValue) ? rightValue : Buffer.from(rightValue);
-        if (!leftValue.equals(rightBuffer)) {
-            return false;
-        }
+    catch {
+        return false;
     }
-    return true;
 }
-export function installTargetsToJson(targets) {
-    return targets.map((target) => ({
-        agent: target.agent,
-        mode: target.mode,
-        destination: target.destination,
-    }));
+function homeDirectory() {
+    return process.env.HOME?.trim() || os.homedir();
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@workbench-ai/workbench",
-  "version": "0.0.73",
+  "version": "0.0.75",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/workbench-ai/workbench.git",
@@ -20,11 +20,12 @@
     "dist"
   ],
   "dependencies": {
+    "skills": "1.5.11",
     "yaml": "^2.8.2",
-    "@workbench-ai/workbench-built-in-adapters": "0.0.73",
-    "@workbench-ai/workbench-protocol": "0.0.73",
-    "@workbench-ai/workbench-contract": "0.0.73",
-    "@workbench-ai/workbench-core": "0.0.73"
+    "@workbench-ai/workbench-built-in-adapters": "0.0.75",
+    "@workbench-ai/workbench-contract": "0.0.75",
+    "@workbench-ai/workbench-core": "0.0.75",
+    "@workbench-ai/workbench-protocol": "0.0.75"
   },
   "devDependencies": {
     "@tailwindcss/postcss": "^4.2.2",
@@ -35,7 +36,7 @@
     "react-dom": "^19.2.0",
     "typescript": "^5.9.2",
     "vitest": "^3.2.4",
-    "@workbench-ai/workbench-ui": "0.0.73"
+    "@workbench-ai/workbench-ui": "0.0.75"
   },
   "scripts": {
     "build": "rm -rf dist && tsc -p tsconfig.json && chmod 755 dist/workbench.js && node ./scripts/build-dev-open-assets.mjs",