@hasna/skills 0.10.91 → 0.10.93

package/dist/lib/agent-discovery.d.ts

@@ -1,4 +1,4 @@
-import type { IntegrationAgent } from "./agent-adapters.js";
+import { type IntegrationAgent } from "./agent-adapters.js";
 import { type DiscoveryDirectory } from "./agent-discovery-directories.js";
 import { type CodexReviewedHookSource } from "./codex-hook-mcp-dependencies.js";
 import { CLAUDE_ORPHAN_MARKER_MODE } from "./claude-plugin-cache-marker.js";
@@ -65,6 +65,19 @@ export interface AgentDiscoveryBinding {
 export declare const DISCOVERY_ROOT_UNRESOLVED = "DISCOVERY_ROOT_UNRESOLVED";
 export declare function discoveryRootUnresolved(agent: IntegrationAgent, command: string, detail: string): Error;
 export declare function isDiscoveryRootUnresolved(error: unknown): error is Error;
+/** A native configuration Skills cannot resolve. The message names the
+ * --discovery-inputs option of the native commands that accept it (hook
+ * install, migrate native). Portable authoring takes no such option and
+ * rewrites the remedy from these fields: `reviewable` marks a hook, plugin hook
+ * or plugin option check that a current discovery review satisfies, and
+ * `source` names the configuration or hook file it checked (a path only). */
+export declare class NativeDiscoveryUnresolved extends Error {
+    readonly agent: IntegrationAgent;
+    readonly detail: string;
+    source?: string | undefined;
+    reviewable: boolean;
+    constructor(agent: IntegrationAgent, detail: string, source?: string | undefined);
+}
 /** The runtime executable a discovery review resolved through PATH, with the
  * realpath its launcher led to. The policy stores it beside the binding
  * (bridge.discoveryExecutables), not inside it, so a consumer that compares
@@ -214,8 +227,21 @@ export declare function resolveAgentDiscoveryExclusionRoots(options: Omit<Discov
     retained?: AgentDiscoveryBinding;
     narrowed?: NarrowedWitnessLedger;
     nativeHome?: string;
+    managedHook?: ManagedBridgeHook;
 }): readonly string[];
 /** Metadata-only closure of aliases inside the selected native discovery
  * trees. Never search the account generally or load a payload/plugin. Each
  * resolved alias remains excluded while unrelated portable paths stay usable. */
 export declare function nativeDiscoveryAliasTargets(roots: readonly string[], home: string): string[];
+/** The Skills bridge command and selection profile the policy records for an
+ * agent (`bridge.commands` and `bridge.profiles`), from which hook install
+ * renders its managed hook commands. */
+export interface ManagedBridgeHook {
+    command: string;
+    profile: string;
+    supervisor?: {
+        path: string;
+        runtime: string;
+        sha256: string;
+    };
+}

package/dist/lib/authoring-path.d.ts

@@ -1,7 +1,12 @@
+import { NativeDiscoveryUnresolved } from "./agent-discovery.js";
 export interface PortableAuthoringPathOptions {
     /** The account whose native discovery must remain free of authored payloads. */
     homeDir?: string;
 }
+/** The authoring form of a native discovery refusal. Authoring commands take
+ * no --discovery-inputs option, so name the command that does, or say that a
+ * review does not resolve it. Names and paths only, never file content. */
+export declare function portableAuthoringDiscoveryRefusal(error: NativeDiscoveryUnresolved, destination: string): string;
 /**
  * Refuse a write target that is, or physically aliases, an agent discovery
  * root. Read-only inventory and archive operations deliberately do not call

package/dist/lib/linux-access-acl.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Linux POSIX ACL absence check (SH-00084).
+ *
+ * Access ACLs change effective permissions independently of mode and group.
+ * The guarded writers do not copy ACLs, so they require verified absence on
+ * supported Linux/glibc. A default ACL initializes direct children at
+ * creation, not existing descendants: query it only for directories where the
+ * caller will create an object.
+ *
+ * Presence is queried only (size 0); no attribute value is read or copied.
+ *
+ * errno is thread-local and any later libc call on this thread, or a signal
+ * handler that does not preserve it, can overwrite it. The probe therefore:
+ * - resets errno before each query where the layer can write it,
+ * - reads it as the very next step after the call, with nothing allocated in
+ *   between (the call returns an immediate number, not a BigInt, and errno is
+ *   read with bun:ffi's read.i32, which allocates nothing),
+ * - re-queries a bounded number of times when the result is -1 with an errno
+ *   other than the two "absent" answers, since a stray overwrite does not
+ *   repeat while a genuine failure does. A persistent failure refuses.
+ * A result other than -1 (the attribute exists, or an anomalous value) always
+ * refuses at once and never depends on errno.
+ */
+/** ENODATA on the asm-generic errno table (Linux x86_64 and aarch64). */
+export declare const LINUX_ENODATA = 61;
+/** EOPNOTSUPP, which glibc also names ENOTSUP, on the asm-generic table. */
+export declare const LINUX_EOPNOTSUPP = 95;
+/** Queries per attribute before an unexplained failure refuses. */
+export declare const LINUX_ACL_QUERY_ATTEMPTS = 4;
+/**
+ * Filesystems where an unsupported POSIX ACL attribute means the kernel
+ * enforces no ACL at all (support compiled out, or mounted with noacl), so
+ * mode and ownership are the whole access model. Network and FUSE filesystems
+ * (NFSv4, SMB, 9p, FUSE and others) also answer EOPNOTSUPP while enforcing
+ * their own ACLs or server-side access, so they stay unverified.
+ */
+export declare const LINUX_ACL_FREE_WHEN_UNSUPPORTED: ReadonlySet<bigint>;
+/** The raw operations, separable so tests can drive every errno path. */
+export interface LinuxAclProbe {
+    /** process.arch of the running binary; only asm-generic errno tables are admitted. */
+    readonly arch: string;
+    /** Thread-local errno of the calling thread, or null when it cannot be located. */
+    readonly errno: {
+        get(): number;
+        set?(value: number): void;
+    } | null;
+    /** fgetxattr(fd, name, NULL, 0): the attribute size, or -1. */
+    fgetxattr(fd: number, attribute: string): number | bigint;
+    /** fstatfs(fd).f_type, or null when fstatfs fails. */
+    filesystemType(fd: number): bigint | null;
+}
+/** True only when every queried POSIX ACL attribute is verifiably absent. */
+export declare function linuxAccessAclAbsent(probe: LinuxAclProbe, fd: number, creationParent: boolean): boolean;
+/** Run with the glibc probe; any loading or ABI failure refuses (false). */
+export declare function withGlibcAclProbe(use: (probe: LinuxAclProbe) => boolean): boolean;

package/dist/runtime-prerequisites.js

@@ -49,7 +49,7 @@ var __require = import.meta.require;
 // src/runtime-prerequisites.ts
 import { isAbsolute as isAbsolute7 } from "path";
 // package.json
-var version = "0.10.91";
+var version = "0.10.93";
 var package_default = {
   name: "@hasna/skills",
   version,