@delorenj/skillex 0.1.3 → 0.3.0

package/dist/commands/bmad.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 BMAD freeze/status/explain; activation stays an explicit, separate step. */
+export declare function registerBmadCommands(program: Command, output: Output): void;
+export {};

package/dist/commands/clients.d.ts

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

package/dist/commands/integrations.d.ts

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

package/dist/commands/roots.d.ts

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

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

@@ -9,7 +9,8 @@ export interface OwnedNode {
     readonly children?: Readonly<Record<string, EntryIdentity>>;
 }
 export interface SourceRevision {
-    readonly kind: "catalog" | "pack";
+    /** Legacy receipts recorded "pack" for whole-root pack sources; they stay readable. */
+    readonly kind: "catalog" | "pack" | "set";
     readonly path: string;
     readonly commit: string | null;
     readonly reason: string | null;

package/dist/core/bmad-freeze.d.ts

@@ -0,0 +1,9 @@
+import type { BmadFreezeData, BmadFreezeOptions } from "./bmad-types.js";
+import { type ResultEnvelope } from "./result.js";
+/**
+ * Freeze the BMAD skills and per-client commands of a BMAD-enabled project into a
+ * versioned reference-only registry pack (ADR-0001). Import is offline, idempotent,
+ * and guarded: same-version repeats change nothing, and a differing existing canonical
+ * body is refused rather than overwritten.
+ */
+export declare function freezeBmadPack(source: string, options?: BmadFreezeOptions): Promise<ResultEnvelope<BmadFreezeData | null>>;

package/dist/core/bmad-source.d.ts

@@ -0,0 +1,40 @@
+import type { BmadCommandInventory, BmadProvenance, BmadSkillManifestEntry } from "./bmad-types.js";
+/** Per-client command layouts discovered on a BMAD-enabled project. Not exhaustive. */
+export declare const BMAD_COMMAND_CLIENTS: ReadonlyArray<{
+    client: string;
+    layout: string;
+}>;
+export declare const BMAD_PACK_NAME = "bmad";
+export declare function sha256File(path: string): Promise<string>;
+/** Expand `~` exactly like other skillex path options; the result must be a real directory. */
+export declare function resolveBmadSource(source: string, options: {
+    cwd?: string;
+}): Promise<string>;
+/** Read the source's own manifests. Entirely offline; nothing is fetched. */
+export declare function inspectBmadSource(sourceRoot: string): Promise<BmadProvenance>;
+/**
+ * Membership source of truth: the source's skill-manifest.csv, reconciled against the
+ * rendered .agents/skills tree. Rendered bmad-* directories absent from the manifest are
+ * inventoried as foreign (installer-owned), never imported silently.
+ */
+export declare function readBmadSkillManifest(sourceRoot: string): Promise<{
+    entries: BmadSkillManifestEntry[];
+    path: string;
+}>;
+export interface BmadCommandScan {
+    readonly inventory: BmadCommandInventory;
+    readonly totalFiles: number;
+    readonly danglingFiles: number;
+}
+export declare function bmadCommandRefs(content: string): string[];
+/**
+ * Copy each client's command layout byte-for-byte. Original assets are preserved; files
+ * whose `_bmad/...` references are dangling in the source install are imported but
+ * reported, never silently rewritten into shims.
+ */
+export declare function scanBmadCommands(sourceRoot: string, packVersionPath: string): Promise<BmadCommandScan>;
+/** Absolute, safe version directory; refuses any traversal outside the pack family. */
+export declare function bmadPackPath(registryRoot: string, version: string): string;
+/** The rendered skill bytes are the only complete source: the source's own tree is pruned. */
+export declare function renderedSkillDir(sourceRoot: string, name: string): string;
+export declare function requireRenderedSkill(sourceRoot: string, name: string): Promise<string>;

package/dist/core/bmad-status.d.ts

@@ -0,0 +1,10 @@
+import type { BmadExplainData, BmadExplainOptions, BmadStatusData, BmadStatusOptions } from "./bmad-types.js";
+import { type ResultEnvelope } from "./result.js";
+/**
+ * Read-only traceability for the BMAD canonical skills present in a registry. Every
+ * frozen BMAD skill is traced against its recorded baseline digest; undeclared pack
+ * children are reported as traceability gaps instead of a misleading green verify.
+ */
+export declare function inspectBmadStatus(options?: BmadStatusOptions): Promise<ResultEnvelope<BmadStatusData | null>>;
+/** Read-only explanation of one canonical BMAD skill: provenance, baseline, references. */
+export declare function explainBmadSkill(name: string, options?: BmadExplainOptions): Promise<ResultEnvelope<BmadExplainData | null>>;

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

@@ -0,0 +1,150 @@
+import type { CatalogLockOptions } from "./catalog-lock.js";
+import type { RegistryOptions, RegistrySelection } from "./selection.js";
+/** Freeze operates only on real local directories; registry URLs are never fetched. */
+export interface BmadFreezeOptions extends RegistryOptions, CatalogLockOptions {
+    readonly version?: string;
+    readonly dryRun?: boolean;
+    readonly replace?: boolean;
+    readonly commands?: boolean;
+}
+export interface BmadSourceModule {
+    readonly name: string;
+    readonly version: string;
+    readonly source: string | null;
+    readonly repoUrl: string | null;
+    readonly sha: string | null;
+}
+export interface BmadSourceInstallation {
+    readonly version: string;
+    readonly installDate: string | null;
+    readonly lastUpdated: string | null;
+}
+/** Evidence captured offline from the source install's own manifests. */
+export interface BmadProvenance {
+    readonly sourceRoot: string;
+    readonly installation: BmadSourceInstallation;
+    readonly modules: readonly BmadSourceModule[];
+    readonly skillManifestSha256: string | null;
+    readonly filesManifestSha256: string | null;
+    readonly filesManifestDeclared: number;
+    readonly filesManifestMissing: number;
+}
+export type BmadInventoryStatus = "imported" | "unchanged" | "skipped" | "failed";
+export interface BmadSkillInventory {
+    readonly name: string;
+    readonly sourcePath: string;
+    readonly status: BmadInventoryStatus;
+    readonly digest: string | null;
+    readonly recordedDigest: string | null;
+}
+/** Skills installed by the source but outside the frozen manifest, inventoried separately. */
+export interface BmadForeignSkill {
+    readonly name: string;
+    readonly path: string;
+}
+export interface BmadSkillManifestEntry {
+    readonly canonicalId: string;
+    readonly name: string;
+    readonly description: string | null;
+    readonly module: string | null;
+    readonly path: string | null;
+}
+export interface BmadCommandClient {
+    readonly client: string;
+    readonly layout: string;
+    readonly directory: string;
+    readonly imported: number;
+    readonly dangling: number;
+}
+export interface BmadCommandFile {
+    readonly name: string;
+    readonly client: string;
+    readonly layout: string;
+    readonly path: string;
+    readonly sourcePath: string;
+    readonly sha256: string;
+    readonly size: number;
+    readonly bmadRefs: readonly string[];
+    readonly danglingRefs: readonly string[];
+}
+export interface BmadCommandInventory {
+    readonly clients: readonly BmadCommandClient[];
+    readonly files: readonly BmadCommandFile[];
+}
+export interface BmadFreezeChange {
+    readonly action: string;
+    readonly path: string;
+    readonly source?: string;
+}
+export interface BmadFreezeData {
+    readonly registry: RegistrySelection;
+    readonly pack: {
+        readonly name: string;
+        readonly version: string;
+        readonly path: string;
+    };
+    readonly provenance: BmadProvenance;
+    readonly sourceRoot: string;
+    readonly dryRun: boolean;
+    readonly skills: readonly BmadSkillInventory[];
+    readonly foreignSkills: readonly BmadForeignSkill[];
+    readonly skillsDeclared: number;
+    readonly skillsImported: number;
+    readonly skillsUnchanged: number;
+    readonly skillsSkipped: number;
+    readonly skillsFailed: number;
+    readonly commands: BmadCommandInventory;
+    readonly commandFiles: number;
+    readonly danglingCommands: number;
+    readonly changes: readonly BmadFreezeChange[];
+}
+export interface BmadStatusOptions extends RegistryOptions {
+    readonly signal?: {
+        readonly aborted: boolean;
+    };
+}
+export type BmadCanonicalState = "ok" | "missing" | "foreign" | "modified";
+export interface BmadCanonicalStatus {
+    readonly name: string;
+    readonly path: string;
+    readonly state: BmadCanonicalState;
+    readonly digest: string | null;
+    readonly recordedDigest: string | null;
+    readonly references: readonly string[];
+    readonly provenance: Readonly<Record<string, unknown>> | null;
+}
+export interface BmadStatusData {
+    readonly registry: RegistrySelection;
+    readonly skills: readonly BmadCanonicalStatus[];
+    readonly traced: number;
+    readonly drifted: readonly string[];
+    readonly untraced: readonly string[];
+    readonly pack: string | null;
+    readonly packMembers: readonly string[];
+    readonly packVerified: boolean | null;
+    readonly findings: readonly import("./result.js").Diagnostic[];
+}
+export interface BmadExplainOptions extends RegistryOptions {
+    readonly signal?: {
+        readonly aborted: boolean;
+    };
+}
+export interface BmadReference {
+    readonly kind: "pack" | "set" | "skill";
+    readonly name: string;
+    readonly version?: string;
+}
+export interface BmadSkillExplanation {
+    readonly name: string;
+    readonly canonicalPath: string | null;
+    readonly digest: string | null;
+    readonly recordedDigest: string | null;
+    readonly modifiedLocally: boolean | null;
+    readonly bmadVersion: string | null;
+    readonly references: readonly BmadReference[];
+    readonly findings: readonly import("./result.js").Diagnostic[];
+}
+export interface BmadExplainData {
+    readonly registry: RegistrySelection;
+    readonly skill: BmadSkillExplanation;
+}

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

@@ -15,6 +15,11 @@ export interface CatalogWriteResult {
 }
 export interface CatalogWriteOptions extends RegistryOptions, CatalogLockOptions {
     readonly dryRun?: boolean;
+    /**
+     * Override the receipt's imported_from label, e.g. a sanitized Git URL
+     * instead of an ephemeral clone path, so provenance outlives the clone.
+     */
+    readonly importedFrom?: string;
 }
 export interface CreateSkillOptions extends CatalogWriteOptions {
     readonly description?: string;

package/dist/core/client-isolation.d.ts

@@ -0,0 +1,74 @@
+import { type ResultEnvelope } from "./result.js";
+import type { ResolveOptions } from "./selection.js";
+export interface ClientIsolationOptions extends Omit<ResolveOptions, "scope" | "inheritGlobal"> {
+    readonly client?: string;
+    readonly apply?: boolean;
+    readonly dryRun?: boolean;
+    /** Explicitly permit the project block to override shared user permissions, never agent rules. */
+    readonly overridePermissions?: boolean;
+    readonly stateHome?: string;
+    readonly timeoutMs?: number;
+}
+export interface ClientVerifyOptions extends Omit<ClientIsolationOptions, "apply" | "dryRun"> {
+    /** A caller-owned, existing probe session. Verification never creates sessions. */
+    readonly session?: string;
+    readonly agent?: string;
+}
+interface Rule {
+    action: string;
+    resource: string;
+    effect: "allow" | "deny" | "ask";
+}
+export interface ClientIsolationPlan {
+    readonly client: "opencode";
+    readonly project: string;
+    readonly set: string | null;
+    readonly members: readonly string[];
+    readonly config: string;
+    readonly receipt: string;
+    readonly changes: readonly {
+        path: string;
+        action: "create" | "update" | "remove";
+    }[];
+    readonly recovery: boolean;
+    readonly overrides: readonly {
+        path: string;
+        rule: number;
+    }[];
+}
+export interface ClientIsolationResult extends ClientIsolationPlan {
+    readonly dryRun: boolean;
+    readonly applied: boolean;
+    readonly runtimeVerified: false;
+}
+export interface ClientVerification {
+    readonly client: "opencode";
+    readonly project: string;
+    readonly set: string;
+    readonly session: string;
+    readonly agent: string;
+    readonly evidence: "opencode-v2-permission-evaluator";
+    readonly registryCount: number;
+    readonly checked: readonly {
+        id: string;
+        expected: Rule["effect"];
+        effect: Rule["effect"];
+        request: string;
+    }[];
+    readonly advertised: readonly string[];
+}
+/** Native V2 API envelope; a transport seam for fixtures, not an alternate evaluator. */
+export type OpenCodeRequest = (method: "get" | "post", path: string, body?: Readonly<Record<string, unknown>>) => Promise<unknown>;
+export declare class ClientIsolationCommand {
+    readonly options: ClientIsolationOptions;
+    readonly remove: boolean;
+    constructor(options: ClientIsolationOptions, remove?: boolean);
+    plan(): Promise<ClientIsolationPlan>;
+    execute(): Promise<ResultEnvelope<ClientIsolationResult | null>>;
+}
+export declare function isolateClient(options: ClientIsolationOptions): Promise<ResultEnvelope<ClientIsolationResult | null>>;
+/** Removes only receipt-owned rules; works after the project set has been unset. */
+export declare function unisolateClient(options: ClientIsolationOptions): Promise<ResultEnvelope<ClientIsolationResult | null>>;
+/** Checks the actual permission service, including agent and session overrides, without inference. */
+export declare function verifyClientIsolation(options: ClientVerifyOptions, request?: OpenCodeRequest): Promise<ResultEnvelope<ClientVerification | null>>;
+export {};

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

@@ -8,6 +8,14 @@ interface LinkIdentity {
     readonly raw: string;
     readonly target: string;
 }
+export interface CompositionDocument {
+    readonly path: string;
+    readonly bytes: Buffer;
+    readonly before?: {
+        bytes: Buffer;
+        info: Stats;
+    };
+}
 export interface CompositionPlan {
     readonly registry: RegistrySelection;
     readonly composition: CompositionDetails;
@@ -15,14 +23,8 @@ export interface CompositionPlan {
     readonly changes: CompositionChange[];
     readonly directories: Map<string, Stats>;
     readonly links: Map<string, LinkIdentity>;
-    manifest?: {
-        path: string;
-        bytes: Buffer;
-        before?: {
-            bytes: Buffer;
-            info: Stats;
-        };
-    };
+    manifest?: CompositionDocument;
+    origin?: CompositionDocument;
 }
 export declare function compositionError<T>(command: string, error: unknown): ResultEnvelope<T | null>;
 export declare function conflict(path: string, message?: string): never;

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

@@ -17,7 +17,7 @@ export interface CompositionDetails {
     readonly description?: string;
 }
 export interface CompositionChange {
-    readonly action: "create-directory" | "create-link" | "remove-link" | "write-manifest";
+    readonly action: "create-directory" | "create-link" | "remove-link" | "write-manifest" | "write-origin";
     readonly path: string;
     readonly target?: string;
 }

package/dist/core/derivation.d.ts

@@ -0,0 +1,59 @@
+import type { CompositionChange, CompositionMutationData, CompositionOptions } from "./composition-types.js";
+import { type ResultEnvelope } from "./result.js";
+import type { RegistrySelection, ScopeName } from "./selection.js";
+import { type DerivedSetDeclaration, type SetOrigin } from "./set-origin.js";
+export interface DerivationOwner {
+    readonly scope: ScopeName;
+    readonly root: string;
+}
+export interface DerivationInputs {
+    readonly base: string | null;
+    readonly packs: readonly string[];
+    readonly skills: readonly string[];
+    readonly removed: readonly string[];
+}
+export interface DerivationPreview {
+    readonly registry: RegistrySelection;
+    readonly owner: DerivationOwner;
+    readonly name: string;
+    readonly path: string;
+    readonly inputs: DerivationInputs;
+    readonly members: readonly {
+        readonly name: string;
+        readonly path: string;
+    }[];
+    readonly creates: boolean;
+    readonly changes: readonly CompositionChange[];
+}
+/** Membership a derived set must materialize: base ∪ packs ∪ skills − removed. */
+export declare function desiredDerivedMembers(registry: string, inputs: DerivationInputs, ancestors?: ReadonlySet<string>): Promise<Map<string, string>>;
+/** Validate the complete derived projection, not just the links that survived. */
+export declare function verifyDerivedMembers(registry: string, inventory: {
+    readonly path: string;
+    readonly names: readonly string[];
+}, derived: DerivedSetDeclaration, ancestors?: ReadonlySet<string>): Promise<void>;
+/** Read the current derivation state of a set, if it is a derived set at all. */
+export declare function derivedState(registry: string, name: string): Promise<{
+    path: string;
+    origin: SetOrigin & {
+        derived: DerivedSetDeclaration;
+    };
+    members: string[];
+} | undefined>;
+/** The name of the derived set this scope owns for the given base. */
+export declare function ownedDerivedName(base: string | null, ownerRoot: string): string;
+/** Read-only derivation preview for command planning and dry runs. */
+export declare function planDerivedSet(options: CompositionOptions & {
+    owner: DerivationOwner;
+    inputs: DerivationInputs;
+}): Promise<DerivationPreview>;
+/** Materialize (or update) the scope-owned derived set. Registry-only write. */
+export declare function materializeDerivedSet(options: CompositionOptions & {
+    owner: DerivationOwner;
+    inputs: DerivationInputs;
+}): Promise<ResultEnvelope<CompositionMutationData | null>>;
+/** Remove only an owned derived set, serialized with every composition writer. */
+export declare function retireDerivedSet(options: CompositionOptions, owner: DerivationOwner, name: string): Promise<ResultEnvelope<{
+    retired: string | null;
+    removed: readonly string[];
+} | null>>;

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

@@ -9,7 +9,7 @@ export interface PathObservation {
     readonly rawTarget: string | null;
     readonly target: string | null;
     readonly reachable: boolean;
-    readonly ownership: "owned" | "foreign" | "changed" | "pack" | "none";
+    readonly ownership: "owned" | "foreign" | "changed" | "set" | "none";
 }
 export interface SkillObservation extends PathObservation {
     readonly name: string;
@@ -30,7 +30,7 @@ export interface StatusScope {
     readonly scope: ScopeName;
     readonly root: string;
     readonly manifestPath: string;
-    readonly mode: "composed" | "pack" | null;
+    readonly mode: "composed" | "set" | null;
     readonly desired: readonly string[] | null;
     readonly actual: {
         readonly root: PathObservation;
@@ -41,7 +41,7 @@ export interface StatusScope {
         readonly actual: number;
         readonly owned: number;
         readonly foreign: number;
-        readonly pack: number;
+        readonly set: number;
         readonly missing: number | null;
     };
     readonly aliases: readonly AliasObservation[];

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

@@ -0,0 +1,131 @@
+import type { CompositionOptions } from "./composition-types.js";
+import { type Diagnostic } from "./result.js";
+export interface SourceEntry {
+    readonly name: string;
+    readonly path: string;
+    readonly disposition: "mapped" | "unmapped" | "divergent" | "broken" | "foreign";
+    readonly canonical?: string;
+    /** Real directory an explicit import would copy from (links resolve first). */
+    readonly importPath?: string;
+    readonly reason?: string;
+}
+export interface SourceProvenance {
+    readonly type: "path" | "git";
+    readonly label: string;
+    readonly commit?: string;
+}
+export interface SourceInventory {
+    readonly label: string;
+    readonly kind: "path" | "git";
+    readonly root: string | undefined;
+    readonly entries: readonly SourceEntry[];
+    readonly provenance: SourceProvenance;
+    readonly temporary: string | undefined;
+    readonly findings: readonly Diagnostic[];
+}
+export interface SourceOptions {
+    readonly cwd?: string;
+    readonly home?: string;
+    readonly signal?: {
+        readonly aborted: boolean;
+    };
+}
+/** One source skill that has no canonical definition yet. */
+export interface PendingImport {
+    readonly name: string;
+    readonly path: string;
+    /** Stable provenance label: sanitized URL (plus commit for Git), never a clone temp path. */
+    readonly label: string;
+}
+export interface MembershipOptions {
+    /** Collect unmapped entries for explicit import instead of refusing on them. */
+    readonly importMissing?: boolean;
+}
+export interface SourceMembership {
+    readonly names: string[];
+    readonly findings: Diagnostic[];
+    readonly imports: PendingImport[];
+}
+/** Options shared by source-backed set/pack creation. */
+export interface SourceCreationOptions extends CompositionOptions {
+    readonly fromRoot?: string;
+    readonly from?: readonly string[];
+    readonly import?: boolean;
+}
+/** The membership slice of {@link PlannedSources} that composition planning consumes. */
+export interface SourceMembershipPlan {
+    readonly members: readonly string[];
+    readonly pending: ReadonlyMap<string, string>;
+    readonly provenance: Record<string, unknown> | undefined;
+}
+/**
+ * Remove URL credentials anywhere they appear — labels, provenance, findings,
+ * and Git transport errors all pass through here — so a token or password
+ * embedded for transport is never echoed back.
+ */
+export declare function sanitizeSourceLabel(source: string): string;
+export declare function releaseInventory(inventory: SourceInventory): Promise<void>;
+export declare function inventorySkillRoot(registry: string, path: string, options?: SourceOptions): Promise<SourceInventory>;
+/**
+ * Inventory one explicitly requested source: an existing local path is read in
+ * place; a Git remote is acquired (clone --depth 1) because it was explicitly
+ * requested, with its commit pinned into provenance. Nothing is executed from
+ * the acquired tree and nothing is imported implicitly.
+ */
+export declare function inventorySource(registry: string, source: string, options?: SourceOptions, pinned?: SourceProvenance): Promise<SourceInventory>;
+/**
+ * Merge inventories into canonical member names. Mapped entries become
+ * members; divergent and broken entries are errors; foreign entries are
+ * preserved and reported. Unmapped entries are errors unless importMissing
+ * collected them for explicit import — a requested entry is never skipped
+ * silently.
+ */
+export declare function membersFromInventories(registry: string, inventories: readonly SourceInventory[], options?: MembershipOptions): Promise<SourceMembership>;
+/**
+ * Acquire every declared source. When a later source fails, every inventory
+ * acquired so far — including its ephemeral clone — is released before the
+ * error propagates, so a failed acquisition never strands a temp tree.
+ */
+export declare function acquireInventories(registryRoot: string, options: SourceCreationOptions): Promise<SourceInventory[]>;
+/** Sources fully planned: membership merged, every import validated write-free. */
+export interface PlannedSources {
+    readonly inventories: readonly SourceInventory[];
+    readonly names: readonly string[];
+    /** Canonical destinations the planned imports will occupy (dry-run results). */
+    readonly pending: ReadonlyMap<string, string>;
+    readonly imports: readonly PendingImport[];
+    readonly findings: readonly Diagnostic[];
+}
+/**
+ * Acquire all sources and plan membership without a single write: every
+ * would-be import is validated through the standing `skill import` machinery
+ * in dry-run first, so an invalid name or unreadable source refuses before
+ * any catalog byte moves. Import failures surface as error findings.
+ */
+export declare function planSourceMembers(registryRoot: string, options: SourceCreationOptions): Promise<PlannedSources>;
+/** An import that actually landed in the catalog. */
+export interface ExecutedImport {
+    readonly name: string;
+    readonly path: string;
+}
+/** Result of executing planned imports for real. */
+export interface ImportExecution {
+    readonly executed: readonly ExecutedImport[];
+    readonly findings: readonly Diagnostic[];
+}
+/**
+ * Execute planned imports for real, reusing the standing `skill import`
+ * machinery. A failing import never invents a rollback or deletes the
+ * definitions earlier imports already wrote — they are standalone
+ * receipt-bearing units — but their survival is disclosed truthfully so the
+ * refusal is never a silent partial state.
+ */
+export declare function executeImports(imports: readonly PendingImport[], options: SourceCreationOptions): Promise<ImportExecution>;
+export declare function provenanceFrom(inventories: readonly SourceInventory[], imported?: readonly string[]): Promise<Record<string, unknown> | undefined>;
+/**
+ * Validate member names with the shared manifest authority and resolve each
+ * to its canonical target. `pending` carries dry-run import destinations for
+ * names whose canonical does not exist yet; every other name must resolve for
+ * real or the operation refuses.
+ */
+export declare function resolveMemberTargets(registry: string, names: readonly string[], label: string, pending?: ReadonlyMap<string, string>): Promise<Map<string, string>>;

package/dist/core/normalization.d.ts

@@ -0,0 +1,15 @@
+import { type ResultEnvelope } from "./result.js";
+import type { SelectionOptions, SelectionResult } from "./selection-command-types.js";
+export interface NormalizeOptions extends SelectionOptions {
+    /** Apply the planned repair. Without it, normalize is a write-free preview. */
+    readonly apply?: boolean;
+    /** Explicit base for a legacy multi-set selection; never guessed from array order. */
+    readonly baseSet?: string;
+}
+/**
+ * Normalize one scope's selection declaration to the corrected set/pack
+ * contract: inventory legacy or conflicted state, fold it into deterministic
+ * exact-membership references, and preview (default) or apply the repair
+ * through the shared selection transaction.
+ */
+export declare function normalizeScope(options?: NormalizeOptions): Promise<ResultEnvelope<SelectionResult | null>>;

package/dist/core/packs.d.ts

@@ -1,8 +1,16 @@
 import type { CompositionMutationData, CompositionOptions, PackListData, PackShowData } from "./composition-types.js";
 import { type ResultEnvelope } from "./result.js";
+export interface CreatePackOptions extends CompositionOptions {
+    /** Existing local skill root whose entries become member references. */
+    readonly fromRoot?: string;
+    /** Repeatable explicit sources: existing paths or Git remotes. */
+    readonly from?: readonly string[];
+    /** Import source skills that have no canonical definition instead of refusing. */
+    readonly import?: boolean;
+}
 export declare function listPacks(options?: CompositionOptions): Promise<ResultEnvelope<PackListData | null>>;
 export declare function showPack(ref: string, options?: CompositionOptions): Promise<ResultEnvelope<PackShowData | null>>;
 export declare function verifyPack(ref: string, options?: CompositionOptions): Promise<ResultEnvelope<PackShowData | null>>;
-export declare function createPack(name: string, version: string, options?: CompositionOptions): Promise<ResultEnvelope<CompositionMutationData | null>>;
+export declare function createPack(name: string, version: string, options?: CreatePackOptions): Promise<ResultEnvelope<CompositionMutationData | null>>;
 export declare function addPackSkills(ref: string, names: readonly string[], options?: CompositionOptions): Promise<ResultEnvelope<CompositionMutationData | null>>;
 export declare function removePackSkills(ref: string, names: readonly string[], options?: CompositionOptions): Promise<ResultEnvelope<CompositionMutationData | null>>;

package/dist/core/profile-policy.d.ts

@@ -1,4 +1,6 @@
 import type { ProfileLocalEntry, ProfileLocation, ProfileOptions } from "./profile-types.js";
 export declare function strictProfile(profile: ProfileLocation, options: ProfileOptions): Promise<boolean>;
+/** Persist a profile's selection boundary independently of the caller's HOME. */
+export declare function profileInheritsGlobal(profile: ProfileLocation): Promise<boolean>;
 export declare function assertStrictProfile(profile: ProfileLocation, options: ProfileOptions, local: readonly ProfileLocalEntry[]): Promise<boolean>;
 export declare function publishStrictPolicy(profile: ProfileLocation): Promise<void>;