@delorenj/skillex 0.1.1

package/dist/commands/compositions.d.ts

@@ -0,0 +1,9 @@
+import type { Command } from "commander";
+import { type ResultEnvelope } from "../index.js";
+interface Output {
+    emit(result: ResultEnvelope<unknown>, text?: string): void;
+    help(command: Command): void;
+}
+/** Register reference composition operations; shared core functions own all IO. */
+export declare function registerCompositionCommands(program: Command, output: Output): void;
+export {};

package/dist/commands/diagnostics.d.ts

@@ -0,0 +1,7 @@
+import { type Command } from "commander";
+import { type ResultEnvelope } from "../index.js";
+interface Output {
+    emit(result: ResultEnvelope<unknown>, text?: string): void;
+}
+export declare function registerDiagnosticCommands(program: Command, output: Output): void;
+export {};

package/dist/commands/migrate.d.ts

@@ -0,0 +1,7 @@
+import type { Command } from "commander";
+import { type ResultEnvelope } from "../index.js";
+interface Output {
+    emit(result: ResultEnvelope<unknown>, text?: string): void;
+}
+export declare function registerMigrationCommand(program: Command, output: Output): void;
+export {};

package/dist/commands/profiles.d.ts

@@ -0,0 +1,8 @@
+import type { Command } from "commander";
+import { type ResultEnvelope } from "../index.js";
+interface Output {
+    emit(result: ResultEnvelope<unknown>, text?: string): void;
+    help(command: Command): void;
+}
+export declare function registerProfileCommands(program: Command, output: Output): void;
+export {};

package/dist/commands/selections.d.ts

@@ -0,0 +1,7 @@
+import { type Command } from "commander";
+import { type ResultEnvelope } from "../index.js";
+interface Output {
+    emit(result: ResultEnvelope<unknown>, text?: string): void;
+}
+export declare function registerSelectionCommands(program: Command, output: Output): void;
+export {};

package/dist/commands/sync.d.ts

@@ -0,0 +1,7 @@
+import { type Command } from "commander";
+import { type ResultEnvelope } from "../index.js";
+interface Output {
+    emit(result: ResultEnvelope<unknown>, text?: string): void;
+}
+export declare function registerSyncCommand(program: Command, output: Output): void;
+export {};

package/dist/commands/vendor.d.ts

@@ -0,0 +1,8 @@
+import type { Command } from "commander";
+import { type ResultEnvelope } from "../index.js";
+interface Output {
+    emit(result: ResultEnvelope<unknown>, text?: string): void;
+    help(command: Command): void;
+}
+export declare function registerVendorCommands(program: Command, output: Output): void;
+export {};

package/dist/core/activation-ownership.d.ts

@@ -0,0 +1,18 @@
+import type { BigIntStats } from "node:fs";
+import type { ActivationData, EntryIdentity, OwnedNode } from "./activation-types.js";
+export interface Entry {
+    readonly path: string;
+    readonly info: BigIntStats;
+    readonly raw?: string;
+}
+export declare function refuse(path: string, message: string, code?: "E_ACTIVATION_CONFLICT" | "E_OWNERSHIP_CHANGED" | "E_ACTIVATION_RECURSIVE" | "E_ACTIVATION_RECEIPT"): never;
+export declare function within(path: string, root: string): boolean;
+export declare function entry(path: string): Promise<Entry | undefined>;
+export declare function identity(item: Entry): EntryIdentity;
+export declare function matches(item: Entry | undefined, expected: EntryIdentity): boolean;
+export declare function requireIdentity(path: string, expected: EntryIdentity, missingOkay?: boolean): Promise<Entry | undefined>;
+export declare function inspectOwnedNode(path: string, node: OwnedNode, missingOkay?: boolean): Promise<boolean>;
+export declare function validateData(raw: unknown, root: string, aliases: readonly string[], receipt: string): ActivationData;
+export declare function emptyData(): ActivationData;
+export declare function replaceOwnership(data: ActivationData, path: string, node?: OwnedNode): ActivationData;
+export declare function lexicalTarget(path: string, raw: string): string;

package/dist/core/activation-state.d.ts

@@ -0,0 +1,37 @@
+import type { LockOptions } from "./lock.js";
+export interface ReceiptOptions extends LockOptions {
+    readonly forbiddenRoots?: readonly string[];
+}
+export interface ReceiptDocument<T> {
+    readonly schema: 2;
+    readonly scopeRoot: string;
+    readonly activationRoot: string;
+    readonly host: string;
+    readonly uid: number | null;
+    readonly data: T;
+}
+/** An IO snapshot, not an ownership claim over any activation filesystem object. */
+export interface ReceiptSnapshot<T> {
+    readonly path: string;
+    readonly scopeRoot: string;
+    readonly activationRoot: string;
+    readonly document?: ReceiptDocument<T>;
+}
+/** Internal target binding; public activation entry points keep their existing namespace and path. */
+export interface ReceiptBinding {
+    readonly namespace: "activations" | "profiles" | "migrations";
+    readonly targetParts: readonly string[];
+}
+/** Validate state placement without creating anything or inspecting activation receipt contents. */
+export declare function validateActivationStateLocation(scopeRoot: string, options?: ReceiptOptions): Promise<void>;
+/** Read and validate local v2 state without creating directories or adopting legacy receipts. */
+export declare function readActivationReceipt<T = unknown>(scopeRoot: string, options?: ReceiptOptions): Promise<ReceiptSnapshot<T>>;
+/** Internal shared state IO; callers supply a fixed target binding, never user-directed receipt paths. */
+export declare function readBoundReceipt<T = unknown>(scopeRoot: string, binding: ReceiptBinding, options?: ReceiptOptions): Promise<ReceiptSnapshot<T>>;
+/**
+ * Persist a complete document while the caller holds the activation ownership lock.
+ * The previous snapshot authorizes only its exact bytes/inode (or continued absence).
+ */
+export declare function writeActivationReceipt<T>(previous: ReceiptSnapshot<T>, data: T, options?: ReceiptOptions): Promise<ReceiptSnapshot<T>>;
+/** Writes retain the original binding and exact opaque snapshot evidence. */
+export declare function writeBoundReceipt<T>(previous: ReceiptSnapshot<T>, data: T, options?: ReceiptOptions): Promise<ReceiptSnapshot<T>>;

package/dist/core/activation-types.d.ts

@@ -0,0 +1,32 @@
+export interface EntryIdentity {
+    readonly kind: "directory" | "link";
+    readonly dev: string;
+    readonly ino: string;
+    readonly raw?: string;
+}
+export interface OwnedNode {
+    readonly identity: EntryIdentity;
+    readonly children?: Readonly<Record<string, EntryIdentity>>;
+}
+export interface SourceRevision {
+    readonly kind: "catalog" | "pack";
+    readonly path: string;
+    readonly commit: string | null;
+    readonly reason: string | null;
+}
+export interface ActivationJournal {
+    readonly id: string;
+    readonly intent: string;
+    readonly path: string;
+    readonly stage: string;
+    readonly parked: string;
+    readonly previous?: OwnedNode;
+    readonly next?: OwnedNode;
+}
+export interface ActivationData {
+    readonly version: 1;
+    readonly links: Readonly<Record<string, EntryIdentity>>;
+    readonly directories: Readonly<Record<string, EntryIdentity>>;
+    readonly sources: readonly SourceRevision[];
+    readonly pending?: ActivationJournal;
+}

package/dist/core/aliases.d.ts

@@ -0,0 +1,7 @@
+import type { ScopeName } from "./selection.js";
+/** Scope aliases shared by reconciliation and diagnostics. */
+export declare const GLOBAL_CLI_ALIASES: readonly [".claude/skills", ".codex/skills", ".gemini/skills", ".copilot/skills", ".kimi-code/skills", ".kimi/skills", ".openclaw/skills", ".config/opencode/skills"];
+export declare const PROJECT_CLI_ALIASES: readonly [".claude/skills", ".codex/skills", ".gemini/skills", ".copilot/skills", ".opencode/skills", ".kimi-code/skills"];
+/** These integrations retain their own installer or profile lifecycle. */
+export declare const NEVER_TOUCH: readonly [".hermes", ".augment", ".cursor", ".crush"];
+export declare function aliasPaths(base: string, scope: ScopeName): readonly string[];

package/dist/core/catalog-lock.d.ts

@@ -0,0 +1,15 @@
+import { type LockOptions } from "./lock.js";
+import type { RegistrySelection } from "./selection.js";
+export interface CatalogLockOptions extends LockOptions {
+    readonly signal?: {
+        readonly aborted: boolean;
+    };
+}
+interface CatalogTransactionOptions extends CatalogLockOptions {
+    readonly allowPendingVendor?: boolean;
+}
+/** Share state-placement rules without reading or writing an activation receipt. */
+export declare function validateCatalogStateLocation(registry: RegistrySelection, options: CatalogLockOptions): Promise<void>;
+/** All Node writers of canonical definition bytes serialize on the catalog itself. */
+export declare function withCatalogLock<T>(registry: RegistrySelection, options: CatalogTransactionOptions, action: () => Promise<T>): Promise<T>;
+export {};

package/dist/core/catalog-types.d.ts

@@ -0,0 +1,28 @@
+import type { RegistryOptions, RegistrySelection } from "./selection.js";
+export interface SkillReference {
+    readonly kind: "set" | "pack";
+    readonly name: string;
+    readonly version?: string;
+    readonly path: string;
+}
+export interface SkillMetadata {
+    readonly description: string | null;
+    readonly metadata: Readonly<Record<string, unknown>>;
+    readonly provenance: Readonly<Record<string, unknown>> | null;
+}
+export interface SkillDetails extends SkillMetadata {
+    readonly name: string;
+    readonly path: string;
+    readonly references: readonly SkillReference[];
+}
+export interface ListSkillsOptions extends RegistryOptions {
+    readonly query?: string;
+}
+export interface SkillListData {
+    readonly registry: RegistrySelection;
+    readonly skills: readonly SkillDetails[];
+}
+export interface SkillShowData {
+    readonly registry: RegistrySelection;
+    readonly skill: SkillDetails;
+}

package/dist/core/catalog-write.d.ts

@@ -0,0 +1,25 @@
+import { type CatalogLockOptions } from "./catalog-lock.js";
+import { type ResultEnvelope } from "./result.js";
+import type { RegistryOptions, RegistrySelection } from "./selection.js";
+export interface CatalogChange {
+    readonly action: string;
+    readonly path: string;
+    readonly source?: string;
+}
+export interface CatalogWriteResult {
+    readonly registry: RegistrySelection;
+    readonly name: string;
+    readonly path: string;
+    readonly dryRun: boolean;
+    readonly changes: readonly CatalogChange[];
+}
+export interface CatalogWriteOptions extends RegistryOptions, CatalogLockOptions {
+    readonly dryRun?: boolean;
+}
+export interface CreateSkillOptions extends CatalogWriteOptions {
+    readonly description?: string;
+}
+/** Scaffold one canonical skill without touching any activation roots. */
+export declare function createSkill(name: string, options?: CreateSkillOptions): Promise<ResultEnvelope<CatalogWriteResult | null>>;
+/** Import a fully inspected local tree, retaining the source and its provenance evidence. */
+export declare function importSkill(source: string, name: string, options?: CatalogWriteOptions): Promise<ResultEnvelope<CatalogWriteResult | null>>;

package/dist/core/catalog.d.ts

@@ -0,0 +1,7 @@
+import type { ListSkillsOptions, SkillListData, SkillShowData } from "./catalog-types.js";
+import { type ResultEnvelope } from "./result.js";
+import type { RegistryOptions } from "./selection.js";
+/** Browse valid canonical definitions while keeping incomplete inspection visible. */
+export declare function listSkills(options?: ListSkillsOptions): Promise<ResultEnvelope<SkillListData | null>>;
+/** Inspect one canonical identity; frontmatter names never redirect its lookup. */
+export declare function showSkill(name: string, options?: RegistryOptions): Promise<ResultEnvelope<SkillShowData | null>>;

package/dist/core/composition-mutation.d.ts

@@ -0,0 +1,38 @@
+import type { Stats } from "node:fs";
+import type { CompositionChange, CompositionDetails, CompositionMutationData, CompositionOptions } from "./composition-types.js";
+import { SkillexError } from "./error.js";
+import { type ResultEnvelope } from "./result.js";
+import type { RegistrySelection } from "./selection.js";
+interface LinkIdentity {
+    readonly info: Stats;
+    readonly raw: string;
+    readonly target: string;
+}
+export interface CompositionPlan {
+    readonly registry: RegistrySelection;
+    readonly composition: CompositionDetails;
+    readonly dryRun: boolean;
+    readonly changes: CompositionChange[];
+    readonly directories: Map<string, Stats>;
+    readonly links: Map<string, LinkIdentity>;
+    manifest?: {
+        path: string;
+        bytes: Buffer;
+        before?: {
+            bytes: Buffer;
+            info: Stats;
+        };
+    };
+}
+export declare function compositionError<T>(command: string, error: unknown): ResultEnvelope<T | null>;
+export declare function conflict(path: string, message?: string): never;
+export declare function requestedSkills(registry: string, names: readonly string[], path: string): Promise<Map<string, string>>;
+export declare function newPlan(registry: RegistrySelection, composition: CompositionDetails, dryRun: boolean): Promise<CompositionPlan>;
+export declare function planDirectory(plan: CompositionPlan, path: string): Promise<void>;
+export declare function inspectCanonicalLink(plan: CompositionPlan, path: string, target: string): Promise<boolean>;
+export declare function planLink(plan: CompositionPlan, path: string, target: string): Promise<void>;
+export declare function planUnlink(plan: CompositionPlan, path: string, target: string): Promise<void>;
+export declare function mutateComposition(command: string, options: CompositionOptions, prepare: () => Promise<CompositionPlan>): Promise<ResultEnvelope<CompositionMutationData | null>>;
+export declare function listOutcome<T>(command: string, value: T, failures: readonly SkillexError[], count: number): ResultEnvelope<T>;
+export declare function collectedError(error: unknown, path: string): SkillexError;
+export {};

package/dist/core/composition-types.d.ts

@@ -0,0 +1,45 @@
+import type { RegistryOptions, RegistrySelection } from "./selection.js";
+export interface CompositionOptions extends RegistryOptions {
+    readonly dryRun?: boolean;
+    readonly description?: string;
+    readonly stateHome?: string;
+    readonly timeoutMs?: number;
+}
+export interface CompositionDetails {
+    readonly kind: "set" | "pack";
+    readonly name: string;
+    readonly version?: string;
+    readonly path: string;
+    readonly skills: readonly {
+        readonly name: string;
+        readonly path: string;
+    }[];
+    readonly description?: string;
+}
+export interface CompositionChange {
+    readonly action: "create-directory" | "create-link" | "remove-link" | "write-manifest";
+    readonly path: string;
+    readonly target?: string;
+}
+export interface CompositionMutationData {
+    readonly registry: RegistrySelection;
+    readonly composition: CompositionDetails;
+    readonly dryRun: boolean;
+    readonly changes: readonly CompositionChange[];
+}
+export interface SetListData {
+    readonly registry: RegistrySelection;
+    readonly sets: readonly CompositionDetails[];
+}
+export interface SetShowData {
+    readonly registry: RegistrySelection;
+    readonly set: CompositionDetails;
+}
+export interface PackListData {
+    readonly registry: RegistrySelection;
+    readonly packs: readonly CompositionDetails[];
+}
+export interface PackShowData {
+    readonly registry: RegistrySelection;
+    readonly pack: CompositionDetails;
+}

package/dist/core/composition.d.ts

@@ -0,0 +1,12 @@
+import type { PackSelection, ResolvedPack } from "./selection.js";
+export declare function canonicalSkill(registry: string, name: string): Promise<string>;
+export declare function setMembers(registry: string, name: string): Promise<{
+    path: string;
+    names: string[];
+}>;
+export declare function setMemberTarget(registry: string, setPath: string, name: string): Promise<string>;
+export interface PackInventory extends ResolvedPack {
+    readonly names: readonly string[];
+}
+/** pack.toml owns membership; its generated skills/ links are checked by verify. */
+export declare function packInventory(registry: string, selection: PackSelection): Promise<PackInventory>;

package/dist/core/content.d.ts

@@ -0,0 +1,25 @@
+export type ContentEntry = {
+    readonly path: string;
+    readonly kind: "directory";
+    readonly mode: number;
+} | {
+    readonly path: string;
+    readonly kind: "file";
+    readonly mode: number;
+    readonly bytes: Buffer;
+} | {
+    readonly path: string;
+    readonly kind: "link";
+    readonly target: string;
+    readonly originalTarget: string;
+    readonly targetPath: string;
+};
+export interface CapturedContent {
+    readonly entries: readonly ContentEntry[];
+    readonly excluded: readonly string[];
+}
+export declare function isWithin(root: string, path: string): boolean;
+/** Capture bytes before mutation and retain every authored support entry. */
+export declare function captureContent(root: string): Promise<CapturedContent>;
+/** Existing Python vendor digest wire format, extended with Git's symlink mode. */
+export declare function digestContent(entries: readonly ContentEntry[]): string;

package/dist/core/diagnostics-types.d.ts

@@ -0,0 +1,76 @@
+import type { SyncChange, SyncOptions } from "./reconciliation-types.js";
+import type { Diagnostic } from "./result.js";
+import type { ExcludedBinding, Resolution, ScopeName, SkillOrigin } from "./selection.js";
+export interface DiagnosticOptions extends Omit<SyncOptions, "dryRun" | "exitCode"> {
+}
+export interface PathObservation {
+    readonly path: string;
+    readonly kind: "missing" | "directory" | "link" | "file" | "other" | "unreadable";
+    readonly rawTarget: string | null;
+    readonly target: string | null;
+    readonly reachable: boolean;
+    readonly ownership: "owned" | "foreign" | "changed" | "pack" | "none";
+}
+export interface SkillObservation extends PathObservation {
+    readonly name: string;
+}
+export interface AliasObservation extends PathObservation {
+    readonly reachesRoot: boolean;
+}
+export interface ReceiptObservation {
+    readonly path: string | null;
+    readonly state: "missing" | "valid" | "pending" | "invalid";
+    readonly pending: {
+        readonly path: string;
+        readonly stage: string;
+        readonly parked: string;
+    } | null;
+}
+export interface StatusScope {
+    readonly scope: ScopeName;
+    readonly root: string;
+    readonly manifestPath: string;
+    readonly mode: "composed" | "pack" | null;
+    readonly desired: readonly string[] | null;
+    readonly actual: {
+        readonly root: PathObservation;
+        readonly entries: readonly SkillObservation[];
+    };
+    readonly counts: {
+        readonly desired: number | null;
+        readonly actual: number;
+        readonly owned: number;
+        readonly foreign: number;
+        readonly pack: number;
+        readonly missing: number | null;
+    };
+    readonly aliases: readonly AliasObservation[];
+    readonly receipt: ReceiptObservation;
+}
+export interface StatusResult {
+    readonly resolution: Resolution | null;
+    readonly writeScopes: readonly ScopeName[];
+    readonly scopes: readonly StatusScope[];
+    readonly changes: readonly SyncChange[];
+}
+export interface SkillExplanation {
+    readonly scope: ScopeName;
+    readonly root: string;
+    readonly manifestPath: string;
+    readonly state: "effective" | "excluded" | "dormant" | "unselected" | "blocked";
+    readonly canonical: string | null;
+    readonly origins: readonly SkillOrigin[];
+    readonly exclusions: readonly ExcludedBinding[];
+    readonly dormant: readonly SkillOrigin[];
+    readonly actual: PathObservation;
+    readonly aliases: readonly {
+        readonly path: string;
+        readonly reachable: boolean;
+    }[];
+    readonly blockers: readonly Diagnostic[];
+}
+export interface ExplainResult {
+    readonly name: string;
+    readonly canonical: string | null;
+    readonly scopes: readonly SkillExplanation[];
+}

package/dist/core/diagnostics.d.ts

@@ -0,0 +1,6 @@
+import type { DiagnosticOptions, ExplainResult, StatusResult } from "./diagnostics-types.js";
+import { ExitCode, type ResultEnvelope } from "./result.js";
+/** Internal shared exit precedence for read-only diagnostics. */
+export declare function diagnosticExit(exits: readonly ExitCode[], drift?: boolean): ExitCode;
+export declare function inspectStatus(options?: DiagnosticOptions): Promise<ResultEnvelope<StatusResult | null>>;
+export declare function explainSkill(name: string, options?: DiagnosticOptions): Promise<ResultEnvelope<ExplainResult | null>>;

package/dist/core/discovery.d.ts

@@ -0,0 +1,5 @@
+import type { DiscoveryOptions, RegistryOptions, RegistrySelection, ScopeDiscovery } from "./selection.js";
+/** Discover read sources separately from the activation scopes selected for writes. */
+export declare function discoverScopes(options?: DiscoveryOptions): Promise<ScopeDiscovery>;
+/** Select one offline checkout. Explicit inputs are exclusive, including invalid ones. */
+export declare function discoverRegistry(options?: RegistryOptions): Promise<RegistrySelection>;

package/dist/core/doctor-sources.d.ts

@@ -0,0 +1,10 @@
+import type { DoctorSourceInspection } from "./doctor-types.js";
+import { type Diagnostic, ExitCode } from "./result.js";
+import type { RegistrySelection } from "./selection.js";
+export interface SourceAudit {
+    readonly data: DoctorSourceInspection;
+    readonly findings: readonly Diagnostic[];
+    readonly exits: readonly ExitCode[];
+}
+/** A source audit accumulates independent failures instead of hiding later violations. */
+export declare function inspectDoctorSources(registry: RegistrySelection): Promise<SourceAudit>;

package/dist/core/doctor-types.d.ts

@@ -0,0 +1,37 @@
+import type { DiagnosticOptions, StatusResult } from "./diagnostics-types.js";
+import type { RegistrySelection } from "./selection.js";
+export interface DoctorOptions extends DiagnosticOptions {
+    readonly sourcesOnly?: boolean;
+    /** Supply the text of `ps -axo pid=,args=` for an isolated observation. */
+    readonly processSnapshot?: () => Promise<string>;
+}
+export interface DoctorSourceInspection {
+    readonly registry: RegistrySelection;
+    readonly canonicalSkills: number;
+    readonly sets: number;
+    readonly packs: number;
+    readonly provenance: number;
+    readonly digestsChecked: number;
+}
+export interface ConfiguredLegacyWriter {
+    readonly kind: "mise" | "service";
+    readonly path: string;
+    readonly line: number;
+    readonly command: string;
+}
+export interface RunningLegacyWriter {
+    readonly pid: number;
+    readonly command: string;
+    readonly entrypoint: string;
+}
+export interface DoctorWriterInspection {
+    readonly configured: readonly ConfiguredLegacyWriter[];
+    readonly running: readonly RunningLegacyWriter[];
+    readonly processObservation: "complete" | "unknown";
+}
+export interface DoctorResult {
+    readonly sourcesOnly: boolean;
+    readonly sources: readonly DoctorSourceInspection[];
+    readonly status: StatusResult | null;
+    readonly writers: DoctorWriterInspection | null;
+}

package/dist/core/doctor-writers.d.ts

@@ -0,0 +1,11 @@
+import type { DoctorOptions, DoctorWriterInspection } from "./doctor-types.js";
+import { type Diagnostic, ExitCode } from "./result.js";
+import type { RegistrySelection } from "./selection.js";
+export declare function inspectDoctorWriters(options: DoctorOptions, registries: readonly RegistrySelection[], scopes: readonly {
+    readonly scope: string;
+    readonly root: string;
+}[]): Promise<{
+    data: DoctorWriterInspection;
+    findings: Diagnostic[];
+    exits: ExitCode[];
+}>;

package/dist/core/doctor.d.ts

@@ -0,0 +1,4 @@
+import type { DoctorOptions, DoctorResult } from "./doctor-types.js";
+import { type ResultEnvelope } from "./result.js";
+/** Aggregate source and activation observations without locks, repair, or network access. */
+export declare function doctor(options?: DoctorOptions): Promise<ResultEnvelope<DoctorResult>>;

package/dist/core/error.d.ts

@@ -0,0 +1,8 @@
+import { type Diagnostic, ExitCode } from "./result.js";
+/** Expected configuration and invariant failures, shared by all core consumers. */
+export declare class SkillexError extends Error {
+    readonly exit: ExitCode;
+    readonly findings: readonly Diagnostic[];
+    constructor(exit: ExitCode, findings: readonly Diagnostic[]);
+}
+export declare function fail(code: Diagnostic["code"], message: string, details?: Omit<Diagnostic, "code" | "severity" | "message">, exit?: ExitCode): never;

package/dist/core/filesystem.d.ts

@@ -0,0 +1,5 @@
+import { type Diagnostic } from "./result.js";
+export declare function inspectPath(path: string): Promise<import("fs").Stats | undefined>;
+export declare function requireDirectory(path: string, missing: Diagnostic["code"]): Promise<string>;
+/** Inspect real composition content without following its canonical skill links. */
+export declare function assertReferenceOnly(root: string): Promise<void>;

package/dist/core/lock.d.ts

@@ -0,0 +1,18 @@
+export interface LockOptions {
+    readonly home?: string;
+    readonly env?: Readonly<Record<string, string | undefined>>;
+    readonly stateHome?: string;
+    readonly timeoutMs?: number;
+}
+/**
+ * Filesystem adaptation of Lamport's bakery algorithm (CACM, August 1974):
+ * https://lamport.azurewebsites.net/pubs/bakery.pdf
+ *
+ * A published unique claim without a ticket is choosing. Its immutable ticket is
+ * max(existing tickets)+1; contenders wait for choosing peers and smaller
+ * (ticket, claim-name) pairs. A later entrant sees the current ticket before
+ * choosing, so newly appearing participants cannot bypass a holder. Local atomic
+ * mkdir/link and coherent directory reads are required; this is not a network
+ * filesystem lease. Only a proven-dead local PID can erase a failed participant.
+ */
+export declare function withLock<T>(resource: string, action: () => Promise<T>, options?: LockOptions): Promise<T>;

package/dist/core/manifest.d.ts

@@ -0,0 +1,7 @@
+import type { SkillsManifest } from "./selection.js";
+export declare function isSkillName(value: unknown): value is string;
+export declare function isVersionComponent(value: unknown): value is string;
+/** Validate without coercion, input mutation, or discarding dormant selections. */
+export declare function parseManifest(raw: unknown, path: string): SkillsManifest;
+/** Read one required declaration. Callers must explicitly handle optional scope absence. */
+export declare function readManifest(path: string): Promise<SkillsManifest>;

package/dist/core/metadata.d.ts

@@ -0,0 +1,6 @@
+import type { SkillMetadata } from "./catalog-types.js";
+export declare function parseSkillMetadata(content: string, path: string): Record<string, unknown>;
+/** Parse already-decoded receipt bytes, including blobs read from a local Git tree. */
+export declare function parseProvenanceMetadata(content: string, path: string): Record<string, unknown>;
+/** Read skill-owned metadata without changing names, provenance fields, or source bytes. */
+export declare function readSkillMetadata(skillPath: string): Promise<SkillMetadata>;

package/dist/core/migration-activation-state.d.ts

@@ -0,0 +1,52 @@
+import { type ReceiptOptions, type ReceiptSnapshot } from "./activation-state.js";
+export interface MigrationIdentity {
+    readonly kind: "directory" | "link" | "file" | "other";
+    readonly dev: string;
+    readonly ino: string;
+    readonly mode: number;
+    readonly raw?: string;
+}
+export interface MigrationNode {
+    readonly identity: MigrationIdentity;
+    readonly hash: string | null;
+    readonly children: Readonly<Record<string, MigrationNode>>;
+}
+export interface MigrationPending {
+    readonly id: string;
+    readonly item: string;
+    readonly path: string;
+    readonly stage: string;
+    readonly parked: string;
+    readonly previous?: MigrationNode;
+    readonly next: MigrationNode;
+    readonly claimRoot: boolean;
+    readonly claimNames: readonly string[];
+}
+export interface MigrationActivationData {
+    readonly version: 1;
+    readonly root: string;
+    readonly verified: Readonly<Record<string, {
+        readonly path: string;
+        readonly digest: string;
+    }>>;
+    readonly pending?: MigrationPending;
+}
+export interface MigrationActivationState {
+    readonly snapshot: ReceiptSnapshot<MigrationActivationData>;
+    readonly data: MigrationActivationData;
+}
+export declare function migrationRefusal(path: string, message: string): never;
+/** Inspect without following any child link; regular files are read through bounded no-follow descriptors. */
+export declare function captureMigrationNode(path: string): Promise<MigrationNode | undefined>;
+export declare function migrationDigest(node: MigrationNode): string;
+export declare function assertMigrationNode(path: string, expected: MigrationNode): Promise<void>;
+export declare function assertMigrationRemainder(path: string, expected: MigrationNode): Promise<MigrationNode | undefined>;
+export declare function removeMigrationNode(path: string, expected: MigrationNode): Promise<void>;
+export declare function readMigrationActivationState(base: string, root: string, aliases: readonly string[], profile: boolean, options: ReceiptOptions): Promise<MigrationActivationState>;
+export declare function writeMigrationActivationState(previous: MigrationActivationState, data: MigrationActivationData): Promise<MigrationActivationState>;
+/** Strict bounded UTF-8 JSON input with stable regular-file evidence. */
+export declare function readLegacyJson(path: string): Promise<{
+    raw: unknown;
+    node: MigrationNode;
+} | undefined>;
+export declare function migrationAbsolute(value: string, home: string, cwd: string): string;