pi-session-mcp 0.7.1 → 0.8.1

package/.pi-session-mcp-cli/config.js

@@ -4,16 +4,20 @@ import { dirname, resolve } from "node:path";
 import { z } from "zod";
 import { MAX_PROFILE_EXTENSIONS, parseExtensionSpec } from "./extension-spec.js";
 import { isMcpServers, snapshotMcpServers } from "./mcp-config.js";
+import { builtinSkillName, isSkillCatalogPath, MAX_PROFILE_SKILLS, MAX_SKILL_CATALOG_ENTRIES } from "./skill-catalog.js";
 import { ALIAS_PATTERN, ImmutableMap, } from "./execution-profile.js";
+import { builtinSkillPath, skillOverrideDirectory } from "./skill-library.js";
 const alias = z.string().regex(ALIAS_PATTERN);
 const permissionProfile = z.enum(["read-only", "coding"]);
 const thinkingLevel = z.enum(["off", "minimal", "low", "medium", "high", "xhigh", "max"]);
 const extensionSpec = z.string().refine((value) => parseExtensionSpec(value) !== undefined);
+const skillCatalogPath = z.string().refine(isSkillCatalogPath);
 const profileSchema = z.object({
     default: z.boolean(), permissionProfile, provider: z.string().trim().min(1).max(256),
     model: z.string().trim().min(1).max(256), thinkingLevel,
     mcpServers: z.custom((value) => isMcpServers(value)).optional(),
     extensions: z.array(extensionSpec).max(MAX_PROFILE_EXTENSIONS).optional(),
+    skills: z.array(alias).max(MAX_PROFILE_SKILLS).optional(),
 }).strict().superRefine((profile, context) => {
     if (profile.mcpServers !== undefined && !isMcpServers(profile.mcpServers, profile.permissionProfile)) {
         context.addIssue({ code: "custom", path: ["mcpServers"], message: "MCP tool grants do not match the permission profile" });
@@ -24,6 +28,9 @@ const profileSchema = z.object({
             context.addIssue({ code: "custom", path: ["extensions"], message: "An extension package may appear only once per profile" });
         }
     }
+    if (profile.skills !== undefined && new Set(profile.skills).size !== profile.skills.length) {
+        context.addIssue({ code: "custom", path: ["skills"], message: "A skill alias may appear only once per profile" });
+    }
 });
 const CONFIG_ERROR_MESSAGES = {
     config_path_required: "Configuration path is required",
@@ -40,6 +47,7 @@ export class ConfigError extends Error {
 }
 export const configSchema = z.object({
     workspaces: z.record(alias, z.string().min(1)),
+    skillCatalog: z.record(alias, skillCatalogPath).refine((catalog) => Object.keys(catalog).length <= MAX_SKILL_CATALOG_ENTRIES).optional(),
     executionProfiles: z.record(alias, profileSchema).superRefine((profiles, context) => {
         const entries = Object.entries(profiles);
         if (entries.length === 0)
@@ -50,13 +58,39 @@ export const configSchema = z.object({
         if (defaults.length === 1 && defaults[0][1].permissionProfile !== "read-only")
             context.addIssue({ code: "custom", message: "The default execution profile must be read-only" });
     }),
-}).strict();
+}).strict().superRefine((config, context) => {
+    // A profile may select only cataloged skills; there is no implicit or default skill.
+    const catalog = config.skillCatalog ?? {};
+    for (const [profileAlias, profile] of Object.entries(config.executionProfiles)) {
+        if ((profile.skills ?? []).some((skill) => !Object.hasOwn(catalog, skill))) {
+            context.addIssue({ code: "custom", path: ["executionProfiles", profileAlias, "skills"], message: "A selected skill must be a skillCatalog alias" });
+        }
+    }
+});
 /** The only supported reload behavior: a running controller keeps the snapshot it loaded at startup. */
 export const RELOAD_POLICY = "restart-required";
 export const CONFIGURATION_FINGERPRINT_PATTERN = /^sha256:[0-9a-f]{64}$/;
 function configurationFingerprint(bytes) {
     return `sha256:${createHash("sha256").update(bytes).digest("hex")}`;
 }
+/**
+ * Resolves a profile's selection against the catalog. Catalog paths resolve like workspaces,
+ * against the configuration file's directory. Two selected aliases on the same path would
+ * load one skill twice under different public names, so they invalidate the configuration.
+ * A `builtin:<name>` value resolves to the library skill: the operator's override, else the shipped one.
+ */
+function resolveSkillSelection(selected, catalog, base, overrideDirectory) {
+    if (selected === undefined || selected.length === 0)
+        return undefined;
+    const resolveEntry = (value) => {
+        const builtin = builtinSkillName(value);
+        return builtin === undefined ? resolve(base, value) : builtinSkillPath(builtin, { overrideDirectory });
+    };
+    const skills = selected.map((skill) => Object.freeze({ alias: skill, path: resolveEntry(catalog[skill]) }));
+    if (new Set(skills.map((skill) => skill.path)).size !== skills.length)
+        throw new ConfigError("invalid_execution_profile_config");
+    return Object.freeze(skills);
+}
 /**
  * The configuration path comes only from the caller or from `PI_SESSION_MCP_CONFIG`.
  * There is no default file: a server's working directory is the client's project,
@@ -85,14 +119,20 @@ export async function loadConfig(path = process.env.PI_SESSION_MCP_CONFIG) {
         throw error;
     }
     const base = dirname(absoluteConfig);
+    const overrideDirectory = skillOverrideDirectory(absoluteConfig);
     const workspaces = new ImmutableMap(Object.entries(parsed.workspaces).map(([key, value]) => [key, resolve(base, value)]));
-    const executionProfiles = new ImmutableMap(Object.entries(parsed.executionProfiles).map(([key, { mcpServers, extensions, ...value }]) => [key, Object.freeze({
-            alias: key, ...value,
-            ...(mcpServers === undefined ? {} : { mcpServers: snapshotMcpServers(mcpServers) }),
-            ...(extensions === undefined ? {} : { extensions: Object.freeze(extensions.map((spec) => parseExtensionSpec(spec))) }),
-        })]));
+    const catalog = parsed.skillCatalog ?? {};
+    const executionProfiles = new ImmutableMap(Object.entries(parsed.executionProfiles).map(([key, { mcpServers, extensions, skills, ...value }]) => {
+        const selection = resolveSkillSelection(skills, catalog, base, overrideDirectory);
+        return [key, Object.freeze({
+                alias: key, ...value,
+                ...(mcpServers === undefined ? {} : { mcpServers: snapshotMcpServers(mcpServers) }),
+                ...(extensions === undefined ? {} : { extensions: Object.freeze(extensions.map((spec) => parseExtensionSpec(spec))) }),
+                ...(selection === undefined ? {} : { skills: selection }),
+            })];
+    }));
     const defaultEntry = [...executionProfiles].find(([, profile]) => profile.default);
     if (!defaultEntry)
         throw new Error("Execution profile configuration is invalid");
-    return { workspaces, executionProfiles, defaultExecutionProfile: defaultEntry[0], configuration };
+    return { workspaces, executionProfiles, defaultExecutionProfile: defaultEntry[0], configuration, skillOverrideDirectory: overrideDirectory };
 }

package/.pi-session-mcp-cli/doctor.js

@@ -1,11 +1,14 @@
-import { access, readFile, readdir, stat } from "node:fs/promises";
+import { access, readFile, readdir, realpath, stat } from "node:fs/promises";
 import { constants } from "node:fs";
 import { join } from "node:path";
 import { loadConfig } from "./config.js";
 import { PiExtensionError } from "./extension-spec.js";
 import { readPackageMetadata } from "./package-metadata.js";
+import { MAX_SKILL_FILE_BYTES } from "./skill-catalog.js";
+import { readSkillBases, SkillBasesError } from "./skill-customize.js";
+import { LEGACY_SKILL_TREE_FINGERPRINT_PATTERN, readSkillTree, releasedSkillFingerprint, shippedSkillsDirectory } from "./skill-library.js";
 const defaultFileSystem = { readFile, stat, access };
-const CHECK_ORDER = ["node_version_unsupported", "package_metadata_unreadable", "build_missing", "build_stale", "version_mismatch", "config_missing", "config_unreadable", "config_invalid", "workspace_missing", "workspace_not_directory", "workspace_unreadable", "workspace_not_writable", "extension_missing", "extension_version_mismatch"];
+const CHECK_ORDER = ["node_version_unsupported", "package_metadata_unreadable", "build_missing", "build_stale", "version_mismatch", "config_missing", "config_unreadable", "config_invalid", "workspace_missing", "workspace_not_directory", "workspace_unreadable", "workspace_not_writable", "extension_missing", "extension_version_mismatch", "skill_missing", "skill_unreadable", "skill_duplicate", "skill_override_outdated"];
 function failure(id, subject, remediation) { return Object.freeze({ id, severity: "error", subject, remediation }); }
 function warning(id, subject, remediation) { return Object.freeze({ id, severity: "warning", subject, remediation }); }
 function ok(id, subject) { return Object.freeze({ id, severity: "ok", subject }); }
@@ -62,6 +65,44 @@ async function productionBuildInputMtimes(root) {
     }
     return mtimes;
 }
+/**
+ * Compares the shipped skills with the fingerprints recorded when the operator copied them.
+ * Reads only the bases file and the shipped files, takes no lock and writes nothing: the bases
+ * file is replaced atomically, so a read sees either the old or the new content.
+ */
+async function skillOverrideChecks(overrideDirectory, shippedDirectory, released) {
+    if (overrideDirectory === undefined)
+        return [];
+    let bases;
+    try {
+        bases = await readSkillBases(overrideDirectory);
+    }
+    catch (error) {
+        if (error instanceof SkillBasesError)
+            return [warning("skill_override_outdated", "skill:bases", "repair or remove the skill bases file")];
+        throw error;
+    }
+    const checks = [];
+    for (const [name, base] of Object.entries(bases).sort(([a], [b]) => a.localeCompare(b))) {
+        let fingerprint;
+        try {
+            fingerprint = (await readSkillTree(join(shippedDirectory, name))).fingerprint;
+        }
+        catch {
+            continue;
+        }
+        const command = `pi-session-mcp-setup --apply --customize-skill ${name}`;
+        // A legacy base is meaningful only as the version 2 value of the released original it names.
+        const recorded = LEGACY_SKILL_TREE_FINGERPRINT_PATTERN.test(base) ? releasedSkillFingerprint(name, base, released) : base;
+        if (recorded === undefined)
+            checks.push(warning("skill_override_outdated", `skill:${name}`, `the recorded base predates version 2 fingerprints and cannot be confirmed; review the shipped skill, then run ${command}`));
+        else
+            checks.push(recorded === fingerprint
+                ? ok("skill_override_outdated", `skill:${name}`)
+                : warning("skill_override_outdated", `skill:${name}`, `review the changed shipped skill, then run ${command}`));
+    }
+    return checks;
+}
 export async function runDoctor(dependencies = {}) {
     const fs = dependencies.fileSystem ?? defaultFileSystem;
     const root = dependencies.packageRoot ?? process.cwd();
@@ -195,6 +236,38 @@ export async function runDoctor(dependencies = {}) {
             }
         }
     }
+    if (config) {
+        for (const [alias, profile] of [...config.executionProfiles].sort(([a], [b]) => a.localeCompare(b))) {
+            const canonical = new Set();
+            for (const skill of profile.skills ?? []) {
+                const subject = `${alias}:${skill.alias}`;
+                let real;
+                try {
+                    const info = await fs.stat(skill.path);
+                    if (!info.isFile() || (info.size ?? 0) > MAX_SKILL_FILE_BYTES)
+                        throw new Error("unusable skill file");
+                    await fs.access(skill.path, constants.R_OK);
+                    real = await (fs.realpath ?? realpath)(skill.path);
+                }
+                catch (error) {
+                    if (isMissing(error))
+                        checks.push(failure("skill_missing", subject, "create the skill file or fix its skillCatalog entry"));
+                    else
+                        checks.push(ok("skill_missing", subject), failure("skill_unreadable", subject, "point the skillCatalog entry to a readable SKILL.md within the size limit"));
+                    continue;
+                }
+                checks.push(ok("skill_missing", subject), ok("skill_unreadable", subject));
+                if (canonical.has(real))
+                    checks.push(failure("skill_duplicate", subject, "select each skill file only once per profile"));
+                else {
+                    canonical.add(real);
+                    checks.push(ok("skill_duplicate", subject));
+                }
+            }
+        }
+    }
+    if (config)
+        checks.push(...await skillOverrideChecks(config.skillOverrideDirectory, shippedSkillsDirectory(dependencies.packageRoot), dependencies.releasedSkillTrees));
     const rank = new Map(CHECK_ORDER.map((id, index) => [id, index]));
     checks.sort((a, b) => (rank.get(a.id) ?? 999) - (rank.get(b.id) ?? 999) || a.subject.localeCompare(b.subject));
     const hasError = checks.some((check) => check.severity === "error");

package/.pi-session-mcp-cli/execution-profile.js

@@ -9,6 +9,7 @@ export function toResolvedExecutionProfile(profile) {
         thinkingLevel: profile.thinkingLevel,
         ...(profile.mcpServers === undefined ? {} : { mcpServers: snapshotMcpServers(profile.mcpServers) }),
         ...(profile.extensions === undefined ? {} : { extensions: profile.extensions }),
+        ...(profile.skills === undefined ? {} : { skills: profile.skills }),
     });
 }
 /** A small read-only map implementation which has no mutating methods at runtime. */

package/.pi-session-mcp-cli/override-lock.js

@@ -0,0 +1,125 @@
+import { spawn } from "node:child_process";
+import { constants } from "node:fs";
+import { lstat, open } from "node:fs/promises";
+import { join } from "node:path";
+import { assertSupportedFilesystem, currentSetupPlatform, isTrustedSystemBinary, openLockedDarwin } from "./setup-platform.js";
+/**
+ * The kernel lock that serializes every read-modify-write of the skill bases file across
+ * processes. It lives on a stable lock file, never on the bases file: that file is replaced by a
+ * rename, which would move the lock onto an unlinked inode. The lock file is never deleted, and a
+ * holder that dies releases the lock through the kernel.
+ */
+export const SKILL_BASES_LOCK_FILE = ".pi-session-mcp-bases.lock";
+export const DEFAULT_OVERRIDE_LOCK_TIMEOUT_MS = 30_000;
+const MIN_LOCK_TIMEOUT_MS = 50;
+const MAX_LOCK_TIMEOUT_MS = 120_000;
+/** Exit status of `flock -E` when the lock stayed busy for the whole wait. */
+const FLOCK_BUSY_EXIT = 75;
+const FLOCK_CANDIDATES = ["/usr/bin/flock", "/bin/flock"];
+export class OverrideLockError extends Error {
+    code;
+    constructor(code) {
+        super("Skill override lock is not available");
+        this.code = code;
+        this.name = "OverrideLockError";
+    }
+}
+/**
+ * Takes the exclusive lock for one override directory, which must exist. Fails closed: an
+ * unsupported platform, a missing trusted `flock`, an unsupported filesystem, a link or non-file
+ * at the lock path and a descriptor that no longer names the path all end in
+ * `override_lock_unavailable`.
+ */
+export async function acquireOverrideLock(overrideDirectory, options = {}) {
+    const platform = currentSetupPlatform(options.platform);
+    if (!platform)
+        throw new OverrideLockError("override_lock_unavailable");
+    const timeoutMs = Number.isFinite(options.timeoutMs) ? Math.max(MIN_LOCK_TIMEOUT_MS, Math.min(options.timeoutMs, MAX_LOCK_TIMEOUT_MS)) : DEFAULT_OVERRIDE_LOCK_TIMEOUT_MS;
+    const flockPath = platform === "linux" ? flockBinary(options) : undefined;
+    if (platform === "linux" && flockPath === undefined)
+        throw new OverrideLockError("override_lock_unavailable");
+    try {
+        await assertSupportedFilesystem(overrideDirectory, platform, options.readStatfs);
+    }
+    catch {
+        throw new OverrideLockError("override_lock_unavailable");
+    }
+    const lockPath = join(overrideDirectory, SKILL_BASES_LOCK_FILE);
+    let handle;
+    try {
+        // macOS takes the kernel lock at open time; on Linux the trusted flock locks this very
+        // open file description, so the lock outlives the flock process and ends with this descriptor.
+        handle = await openLockFile(lockPath, platform, timeoutMs, options.signal);
+        if (flockPath !== undefined)
+            await lockWithFlock(flockPath, handle.fd, timeoutMs, options.signal);
+        // The path may have been replaced while waiting: the lock only counts on the file it names.
+        const [descriptor, linked] = await Promise.all([handle.stat(), lstat(lockPath)]);
+        if (!descriptor.isFile() || !linked.isFile() || descriptor.dev !== linked.dev || descriptor.ino !== linked.ino)
+            throw new OverrideLockError("override_lock_unavailable");
+    }
+    catch (error) {
+        await handle?.close().catch(() => undefined);
+        throw error instanceof OverrideLockError ? error : new OverrideLockError("override_lock_unavailable");
+    }
+    const held = handle;
+    let released = false;
+    return {
+        async release() {
+            if (released)
+                return;
+            released = true;
+            await held.close().catch(() => undefined);
+        },
+    };
+}
+function flockBinary(options) {
+    const trusted = options.isTrustedBinary ?? ((path) => isTrustedSystemBinary(path));
+    return (options.flockCandidates ?? FLOCK_CANDIDATES).find((candidate) => trusted(candidate));
+}
+async function openLockFile(lockPath, platform, timeoutMs, signal) {
+    try {
+        if (platform === "darwin")
+            return await openLockedDarwin(lockPath, { timeoutMs, ...(signal ? { signal } : {}) });
+        return await open(lockPath, constants.O_CREAT | constants.O_RDWR | constants.O_NOFOLLOW, 0o600);
+    }
+    catch (error) {
+        throw new OverrideLockError(error.message === "ownership_lock_busy" ? "override_lock_busy" : "override_lock_unavailable");
+    }
+}
+function lockWithFlock(flockPath, lockFd, timeoutMs, signal) {
+    return new Promise((resolve, reject) => {
+        if (signal?.aborted) {
+            reject(new OverrideLockError("override_lock_unavailable"));
+            return;
+        }
+        let locker;
+        try {
+            // flock parses fractional seconds with the locale's decimal separator, so only whole
+            // seconds go on the command line. The exact bound is the timer below, which stops flock.
+            const wholeSeconds = String(Math.max(1, Math.ceil(timeoutMs / 1_000)));
+            locker = spawn(flockPath, ["-E", String(FLOCK_BUSY_EXIT), "-w", wholeSeconds, "3"], { stdio: ["ignore", "ignore", "ignore", lockFd], detached: true });
+        }
+        catch {
+            reject(new OverrideLockError("override_lock_unavailable"));
+            return;
+        }
+        let expired = false;
+        const stop = () => { if (locker.pid !== undefined) {
+            try {
+                process.kill(-locker.pid, "SIGKILL");
+            }
+            catch { /* already gone */ }
+        } };
+        const cleanup = () => { clearTimeout(bound); signal?.removeEventListener("abort", stop); };
+        const bound = setTimeout(() => { expired = true; stop(); }, timeoutMs);
+        signal?.addEventListener("abort", stop, { once: true });
+        locker.once("error", () => { cleanup(); reject(new OverrideLockError("override_lock_unavailable")); });
+        locker.once("close", (code) => {
+            cleanup();
+            if (code === 0)
+                resolve();
+            else
+                reject(new OverrideLockError(code === FLOCK_BUSY_EXIT || expired ? "override_lock_busy" : "override_lock_unavailable"));
+        });
+    });
+}

package/.pi-session-mcp-cli/setup-platform.js

@@ -0,0 +1,195 @@
+import { execFile } from "node:child_process";
+import { constants, readdirSync, readFileSync, statSync } from "node:fs";
+import { open, statfs } from "node:fs/promises";
+export function currentSetupPlatform(platform = process.platform) {
+    return platform === "linux" || platform === "darwin" ? platform : undefined;
+}
+/** A regular, root-owned executable that no group or other user can replace. */
+export function isTrustedSystemBinary(path, statFile = statSync) {
+    try {
+        const file = statFile(path);
+        return file.isFile() && file.uid === 0 && (file.mode & 0o022) === 0 && (file.mode & 0o111) !== 0;
+    }
+    catch {
+        return false;
+    }
+}
+function readLinuxProcessGroup(pid) {
+    const line = readFileSync(`/proc/${pid}/stat`, "utf8").trim();
+    const close = line.lastIndexOf(") ");
+    const state = line[close + 2];
+    if (close < 3 || !state || !/^[A-Za-z]$/.test(state) || line[close + 3] !== " ")
+        throw new Error("process_stat_invalid");
+    const fields = line.slice(close + 4).trim().split(/\s+/);
+    const group = Number(fields[1]);
+    if (!Number.isSafeInteger(group) || group < 0)
+        throw new Error("process_group_invalid");
+    return { group, state };
+}
+function linuxGroupState(group) {
+    let entries;
+    try {
+        entries = readdirSync("/proc", { withFileTypes: true });
+    }
+    catch {
+        return "unknown";
+    }
+    for (const entry of entries) {
+        if (!entry.isDirectory() || !/^\d+$/.test(entry.name))
+            continue;
+        try {
+            const sample = readLinuxProcessGroup(Number(entry.name));
+            if (sample.group === group && sample.state !== "Z")
+                return "alive";
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                return "unknown";
+        }
+    }
+    return "gone";
+}
+function linuxTableReadable(selfPid) {
+    let sawSelf = false;
+    try {
+        for (const entry of readdirSync("/proc", { withFileTypes: true })) {
+            if (!entry.isDirectory() || !/^\d+$/.test(entry.name))
+                continue;
+            try {
+                const pid = Number(entry.name);
+                readLinuxProcessGroup(pid);
+                if (pid === selfPid)
+                    sawSelf = true;
+            }
+            catch (error) {
+                if (error.code !== "ENOENT")
+                    return false;
+            }
+        }
+    }
+    catch {
+        return false;
+    }
+    return sawSelf;
+}
+export const DARWIN_PS_PATH = "/bin/ps";
+const PS_ARGUMENTS = ["-A", "-o", "pid=,pgid=,stat="];
+const PS_TIMEOUT_MS = 2_000;
+const PS_MAX_OUTPUT_BYTES = 1_048_576;
+/** Parses `ps -A -o pid=,pgid=,stat=`; any unexpected line rejects the whole sample. */
+export function parsePsTable(output) {
+    const body = output.endsWith("\n") ? output.slice(0, -1) : output;
+    if (body.length === 0)
+        return undefined;
+    const entries = [];
+    for (const line of body.split("\n")) {
+        const match = /^\s*(\d+)\s+(\d+)\s+(\S+)\s*$/.exec(line);
+        if (!match)
+            return undefined;
+        const pid = Number(match[1]);
+        const group = Number(match[2]);
+        if (!Number.isSafeInteger(pid) || !Number.isSafeInteger(group))
+            return undefined;
+        entries.push({ pid, group, state: match[3] });
+    }
+    return entries;
+}
+function runDarwinPs() {
+    if (!isTrustedSystemBinary(DARWIN_PS_PATH))
+        return Promise.resolve(undefined);
+    return new Promise((resolve) => {
+        try {
+            execFile(DARWIN_PS_PATH, [...PS_ARGUMENTS], { env: { LC_ALL: "C" }, timeout: PS_TIMEOUT_MS, maxBuffer: PS_MAX_OUTPUT_BYTES, encoding: "utf8" }, (error, stdout) => {
+                // A non-zero exit, timeout, output overflow or spawn failure is indeterminate.
+                resolve(error ? undefined : { exitCode: 0, stdout });
+            });
+        }
+        catch {
+            resolve(undefined);
+        }
+    });
+}
+export function createProcessTable(platform, dependencies = {}) {
+    const selfPid = dependencies.selfPid ?? process.pid;
+    if (platform === "linux") {
+        return { pollMs: 10, groupState: async (group) => linuxGroupState(group), readable: async () => linuxTableReadable(selfPid) };
+    }
+    const runPs = dependencies.runPs ?? runDarwinPs;
+    const scan = async () => {
+        const output = await runPs();
+        if (!output || output.exitCode !== 0)
+            return undefined;
+        const entries = parsePsTable(output.stdout);
+        // A sample without the caller cannot be a complete process table.
+        return entries?.some((entry) => entry.pid === selfPid) ? entries : undefined;
+    };
+    return {
+        pollMs: 50,
+        async groupState(group) {
+            const entries = await scan();
+            if (!entries)
+                return "unknown";
+            return entries.some((entry) => entry.group === group && !entry.state.startsWith("Z")) ? "alive" : "gone";
+        },
+        async readable() { return (await scan()) !== undefined; },
+    };
+}
+// Kernel flock and directory fsync semantics are accepted only on the local
+// Linux filesystems covered by the setup test matrix.
+const SUPPORTED_LINUX_FILESYSTEMS = new Set([
+    0xef53, // ext2/3/4
+    0x58465342, // XFS
+    0x9123683e, // Btrfs
+    0x01021994, // tmpfs
+    0x794c7630, // overlayfs
+    0x2fc12fc1, // ZFS
+    0xf2f52010, // F2FS
+    0x24051905, // UBIFS
+    0xca451a4e, // bcachefs
+]);
+export async function assertSupportedFilesystem(path, platform, readStatfs = (target) => statfs(target)) {
+    const filesystem = await readStatfs(path);
+    if (platform === "linux") {
+        if (!SUPPORTED_LINUX_FILESYSTEMS.has(filesystem.type))
+            throw new Error("ownership_filesystem_unsupported");
+        return;
+    }
+    // macOS assigns f_type dynamically, so the directory must share the type of
+    // `/`, the sealed APFS system volume on every macOS that Node.js 22 supports.
+    if (filesystem.type !== (await readStatfs("/")).type)
+        throw new Error("ownership_filesystem_unsupported");
+}
+/** From XNU `bsd/sys/fcntl.h`; Node's `fs.constants` does not export these. */
+export const DARWIN_O_NONBLOCK = 0x4;
+export const DARWIN_O_EXLOCK = 0x20;
+/**
+ * Opens the lock file with an exclusive lock on its open file description,
+ * which has flock(2) semantics on macOS. A busy lock is retried until the
+ * acquisition bound; a failed attempt holds no descriptor.
+ */
+export async function openLockedDarwin(path, options) {
+    const openFile = options.openFile ?? ((target, flags, mode) => open(target, flags, mode));
+    const flags = constants.O_CREAT | constants.O_RDWR | constants.O_NOFOLLOW | DARWIN_O_EXLOCK | DARWIN_O_NONBLOCK;
+    const boundMs = Number.isFinite(options.timeoutMs) ? Math.max(1_000, Math.min(options.timeoutMs, 120_000)) : 120_000;
+    const deadline = Date.now() + boundMs;
+    const retryMs = options.retryMs ?? 50;
+    while (true) {
+        if (options.signal?.aborted)
+            throw new Error("operation_aborted");
+        try {
+            return await openFile(path, flags, 0o600);
+        }
+        catch (error) {
+            const code = error.code;
+            if (code !== "EAGAIN" && code !== "EWOULDBLOCK")
+                throw new Error("ownership_lock_unavailable");
+        }
+        if (Date.now() >= deadline)
+            throw new Error("ownership_lock_busy");
+        await new Promise((resolve) => {
+            const done = () => { clearTimeout(timer); options.signal?.removeEventListener("abort", done); resolve(); };
+            const timer = setTimeout(done, retryMs);
+            options.signal?.addEventListener("abort", done, { once: true });
+        });
+    }
+}

package/.pi-session-mcp-cli/setup-result.js

@@ -0,0 +1,8 @@
+export function result(operation, findings, status = findings.some((finding) => finding.status === "failed" || finding.status === "divergent" || finding.status === "unsupported") ? "failed" : "ok", exitCode = status === "failed" ? 1 : 0) {
+    const normalized = findings.map((finding) => Object.freeze({
+        target: Object.freeze({ ...finding.target }),
+        status: finding.status,
+        code: /^[a-z][a-z0-9_]{0,63}$/.test(finding.code) ? finding.code : "operation_failed",
+    }));
+    return Object.freeze({ schemaVersion: 1, operation, status, findings: Object.freeze(normalized), exitCode });
+}

package/.pi-session-mcp-cli/skill-catalog.js

@@ -0,0 +1,35 @@
+import { BUILTIN_SKILL_PREFIX, SKILL_NAME_PATTERN } from "./skill-library.js";
+export const MAX_SKILL_CATALOG_ENTRIES = 64;
+export const MAX_PROFILE_SKILLS = 16;
+export const MAX_SKILL_PATH_LENGTH = 4096;
+/** Upper bound for one selected `SKILL.md`, checked before the Pi SDK reads it. */
+export const MAX_SKILL_FILE_BYTES = 256 * 1024;
+export const SKILL_FILE_NAME = "SKILL.md";
+/** `npm:`, `git+ssh:`, `https:`, `file:` and any other scheme-prefixed source. */
+const SCHEME_PREFIX = /^[A-Za-z][A-Za-z0-9+.-]*:/;
+const GLOB_CHARACTERS = /[*?[\]{}]/;
+/** The library skill name of a `builtin:<name>` catalog value; undefined for every other value. */
+export function builtinSkillName(value) {
+    if (!value.startsWith(BUILTIN_SKILL_PREFIX))
+        return undefined;
+    const name = value.slice(BUILTIN_SKILL_PREFIX.length);
+    return SKILL_NAME_PATTERN.test(name) ? name : undefined;
+}
+/**
+ * Whether a configured catalog value names exactly one local `SKILL.md`: its last path segment
+ * is `SKILL.md`, and it is no URL or other scheme-prefixed source, no `~` home shorthand, no
+ * glob and no Windows-style path. So it can never stand for a directory, a pattern or a
+ * remote source. Relative values are resolved later against the configuration file's directory.
+ * The one scheme-prefixed form accepted is `builtin:<name>`, which names a library skill.
+ */
+export function isSkillCatalogPath(value) {
+    if (value.length === 0 || value.length > MAX_SKILL_PATH_LENGTH)
+        return false;
+    if (value.includes("\0") || value.includes("\\") || value.startsWith("~"))
+        return false;
+    if (builtinSkillName(value) !== undefined)
+        return true;
+    if (SCHEME_PREFIX.test(value) || GLOB_CHARACTERS.test(value))
+        return false;
+    return value.split("/").at(-1) === SKILL_FILE_NAME;
+}