@phnx-labs/agents-cli 1.22.119 → 1.22.121

package/dist/lib/redact.js

@@ -1,43 +1,22 @@
-/**
- * Shared redaction helpers for text that may be exported or logged.
- */
 const SECRET_PATTERNS = [
-    // Local home paths identify operators and disclose internal filesystem layout.
-    // Keep the useful path suffix while masking the machine-specific home prefix.
     [/(^|[\s,"'`(=:])\/(?:home|Users)\/[^/\s,"'`]+/g, '$1[HOME]'],
     [/(^|[\s,"'`(=])[A-Z]:\\Users\\[^\\\s,"'`]+/gi, '$1[HOME]'],
     [/\bAKIA[0-9A-Z]{16}\b/g, '[REDACTED_AWS_KEY]'],
-    // GitHub: classic PATs (ghp_), OAuth (gho_), app/refresh/server tokens
-    // (ghs_/ghr_), and fine-grained PATs (github_pat_). All share the 36-char
-    // classic body; fine-grained tokens are longer, so match greedily.
     [/\bghp_[A-Za-z0-9]{36}\b/g, '[REDACTED_GITHUB_TOKEN]'],
     [/\bgh[osru]_[A-Za-z0-9]{36}\b/g, '[REDACTED_GITHUB_TOKEN]'],
     [/\bgithub_pat_[A-Za-z0-9_]{22,}\b/g, '[REDACTED_GITHUB_TOKEN]'],
-    // Anthropic credentials, before the generic sk- rule so the marker is specific
-    // (the generic rule would otherwise swallow them first). Covers every kind of
-    // sk-ant token by matching the kind segment generically: API keys
-    // (sk-ant-api03-…) AND the long-lived OAuth setup-tokens (sk-ant-oat01-…) that
-    // `claude setup-token` mints. The generic sk- rule below CANNOT match an oat01
-    // token — the hyphen after `ant` breaks its [A-Za-z0-9]{20,} run — so without
-    // this an OAuth setup-token leaks verbatim into any log/export (#1767).
     [/\bsk-ant-[a-z0-9]{3,8}-[A-Za-z0-9_-]{8,}\b/g, '[REDACTED_ANTHROPIC_KEY]'],
-    // Stripe live secret / restricted keys.
     [/\b[rs]k_live_[A-Za-z0-9]{20,}\b/g, '[REDACTED_STRIPE_KEY]'],
     [/\bsk-[A-Za-z0-9]{20,}\b/g, '[REDACTED_API_KEY]'],
-    // Slack bot/user/app-level tokens (xoxb-/xoxp-/xapp-…).
     [/\bxox[bp]-[A-Za-z0-9-]{10,}\b/g, '[REDACTED_SLACK_TOKEN]'],
     [/\bxapp-[A-Za-z0-9-]{10,}\b/g, '[REDACTED_SLACK_TOKEN]'],
     [/\bnpm_[A-Za-z0-9]{36}\b/g, '[REDACTED_NPM_TOKEN]'],
     [/\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b/g, '[REDACTED_JWT]'],
-    // Headers frequently appear inside shell arguments. Consume a quoted header
-    // as one unit so cookie attributes after a space do not survive redaction.
     [/(^|\s)(["'])(Cookie|Set-Cookie|Authorization|Proxy-Authorization)\s*:\s*.*?\2/gi, '$1$2$3: [REDACTED]$2'],
     [/(^|\s)(["'])(Cookie|Set-Cookie|Authorization|Proxy-Authorization)\s*:\s*(?:(?!\2).)*$/gi, '$1$2$3: [REDACTED]'],
     [/Bearer\s+\S+/gi, 'Bearer [REDACTED]'],
     [/\b((?:Cookie|Set-Cookie)\s*:\s*)\S+/gi, '$1[REDACTED]'],
     [/\b(Authorization\s*:\s*)(?!Bearer\s+\[REDACTED\])\S+(?:\s+\S+)?/gi, '$1[REDACTED]'],
-    // Structured secret fields can arrive as raw JSON output rather than an
-    // argument object, so the object walker alone is not sufficient.
     [/(^[,{\s]|["'])([A-Z0-9_-]*(?:TOKEN|KEY|SECRET|PASSWORD|AUTHORIZATION|COOKIE)[A-Z0-9_-]*["']?\s*:\s*)(["'][^"']*["']|[^,}\]\s]+)/gim, '$1$2"[REDACTED]"'],
     [/(\s--?(?:password|token|secret|api[_-]?key)(?:=|\s+))(["']?)[^\s"']+\2/gi, '$1[REDACTED]'],
     [/(\s--user(?:=|\s+))(["']?)[^\s"']+\2/gi, '$1[REDACTED]'],
@@ -52,11 +31,9 @@ const BEL = 0x07;
 const CSI_8BIT = 0x9b;
 const OSC_8BIT = 0x9d;
 const ST_8BIT = 0x9c;
-/** C0 controls (minus \t \n \r), DEL, and the C1 range. */
 function isControlByte(c) {
     return (c <= 0x08) || c === 0x0b || c === 0x0c || (c >= 0x0e && c <= 0x1f) || (c >= 0x7f && c <= 0x9f);
 }
-/** End (exclusive) of a CSI parameter/intermediate/final run starting at `i`, or `i` when unterminated. */
 function csiEnd(text, i) {
     let j = i;
     while (j < text.length && text.charCodeAt(j) >= 0x30 && text.charCodeAt(j) <= 0x3f)
@@ -67,28 +44,18 @@ function csiEnd(text, i) {
         return j + 1;
     return i;
 }
-/**
- * Remove terminal control sequences from untrusted text before storage or display.
- *
- * A single forward scan, not a regex: an OSC lookup for its terminator (BEL or
- * ESC-\) is the classic polynomial-backtracking shape, and untrusted text can be
- * built to trigger it. Each character is visited a bounded number of times here.
- */
 export function sanitizeForTerminal(text) {
     if (!text)
         return text;
     let out = '';
     let i = 0;
     const n = text.length;
-    // Once an 8-bit OSC scan reaches the end without a terminator, no later one can find one either.
     let noOsc8Terminator = false;
     while (i < n) {
         const c = text.charCodeAt(i);
         if (c === ESC && i + 1 < n) {
             const next = text.charCodeAt(i + 1);
             if (next === 0x5d) {
-                // OSC: runs to BEL or ESC-\. Any other ESC aborts the sequence, so the
-                // scan never re-covers ground a later OSC start could claim.
                 let j = i + 2;
                 while (j < n && text.charCodeAt(j) !== BEL && text.charCodeAt(j) !== ESC)
                     j++;
@@ -145,16 +112,8 @@ export function sanitizeForTerminal(text) {
     }
     return out;
 }
-/** Env vars whose NAME marks their VALUE as a credential worth masking literally. */
 const SECRET_ENV_NAME = /(?:TOKEN|KEY|SECRET|PASSWORD)/i;
-/** Don't literal-mask trivially short values — they collide with ordinary text. */
 const MIN_KNOWN_VALUE_LEN = 6;
-/**
- * Scrub secrets from `text`. Two passes: format-based patterns (above), then a
- * value-aware pass that masks any `knownValues` verbatim — a credential we
- * already hold in hand leaks regardless of its format, so an exact-value match
- * catches tokens the regexes don't recognize.
- */
 export function redactSecrets(text, knownValues) {
     let safe = text;
     for (const [pattern, replacement] of SECRET_PATTERNS) {
@@ -169,12 +128,6 @@ export function redactSecrets(text, knownValues) {
     }
     return safe;
 }
-/**
- * Secret values already present in the environment (e.g. an injected secrets
- * bundle), selected by secret-shaped var NAME. These are the "known" values fed
- * to {@link redactSecrets} so an exported transcript can't leak a live
- * credential verbatim even when its format matches no pattern.
- */
 export function knownSecretValuesFromEnv(env = process.env) {
     const out = [];
     for (const [name, value] of Object.entries(env)) {
@@ -186,13 +139,6 @@ export function knownSecretValuesFromEnv(env = process.env) {
     return out;
 }
 const EMAIL_RE = /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g;
-/**
- * Mask email addresses in already-rendered text. A published page's sensitive-
- * content scan refuses a body containing an email (`artifacts share` does the
- * same), and almost every real transcript carries a few — git author addresses,
- * `gh api user`, a pasted log. Masking them here means the page genuinely does
- * not carry them, rather than training callers to pass `--force`.
- */
 export function redactEmails(text) {
     return text.replace(EMAIL_RE, '[EMAIL]');
 }

package/dist/lib/refresh-coordinator.d.ts

@@ -2,24 +2,9 @@ export declare function setRefreshLockRootForTest(root: string | null): string |
 interface RefreshLeaseOptions<T> {
     scope: string;
     key: string;
-    /**
-     * Re-read the shared result after taking the lease. If another process
-     * refreshed it while this caller waited, return that value instead of
-     * repeating the provider request.
-     */
     readCompleted: () => T | null;
     isCompleted: (value: T) => boolean;
     refresh: () => Promise<T>;
 }
-/**
- * Serialize refresh work across every agents-cli process on this device.
- *
- * In-process promise maps only protect one Node process. Factory, the daemon,
- * and `agents view` are separate processes, so they need an
- * OS-visible lease. The result is re-read after lock acquisition: a waiter
- * consumes the winner's publication and never calls the provider a second
- * time. `proper-lockfile` supplies heartbeat + stale-owner recovery while an
- * async provider request is in flight.
- */
 export declare function withRefreshLease<T>(options: RefreshLeaseOptions<T>): Promise<T>;
 export {};

package/dist/lib/refresh-coordinator.js

@@ -15,16 +15,6 @@ function lockTarget(scope, key) {
     const digest = createHash('sha256').update(`${scope}\0${key}`).digest('hex');
     return path.join(refreshLockRootOverride ?? getCacheDir(), 'refresh-locks', scope, `${digest}.lock`);
 }
-/**
- * Serialize refresh work across every agents-cli process on this device.
- *
- * In-process promise maps only protect one Node process. Factory, the daemon,
- * and `agents view` are separate processes, so they need an
- * OS-visible lease. The result is re-read after lock acquisition: a waiter
- * consumes the winner's publication and never calls the provider a second
- * time. `proper-lockfile` supplies heartbeat + stale-owner recovery while an
- * async provider request is in flight.
- */
 export async function withRefreshLease(options) {
     const target = lockTarget(options.scope, options.key);
     await fs.mkdir(path.dirname(target), { recursive: true });

package/dist/lib/refresh.d.ts

@@ -1,54 +1,15 @@
-/**
- * Materialization helpers — install manifest CLIs, register MCP servers,
- * sync resources into installed version homes, register hooks, add shims to
- * PATH, prompt for missing default versions, install declared host-CLIs.
- *
- * The reconcile stage behind `agents sync` (the umbrella `--local` path calls
- * this; see sync-umbrella.ts) and any other caller that needs to re-derive local
- * state from declared configuration. Does NOT do any git operations — that lives
- * in `agents repo pull`.
- */
 import type { AgentId } from './types.js';
 import { type ResourceSelection } from './installations/versions.js';
 interface RefreshOptions {
-    /** Limit operations to a single agent (claude/codex/etc). Default: all installed. */
     agentFilter?: AgentId;
-    /** Auto-sync everything and skip interactive prompts. */
     skipPrompts?: boolean;
-    /** Skip CLI version install/upgrade from agents.yaml. */
     skipClis?: boolean;
-    /**
-     * Suppress human progress lines on stdout. Required for machine consumers
-     * (`agents sync --json` / fleet fan-out) so stdout stays a single JSON object.
-     */
     quiet?: boolean;
-    /** Limit reconciliation to the requested resource kinds/names. */
     selection?: ResourceSelection;
-    /** Explicit consent for selected plugins that add executable surfaces. */
     allowExecSurfaces?: boolean;
 }
-/**
- * Re-materialize local state from declared configuration: install CLI versions,
- * register MCP servers, sync resources to version homes, register hooks, add
- * shims to PATH, prompt for missing defaults, install declared host-CLIs.
- *
- * Idempotent — safe to run repeatedly. No network operations.
- */
-/**
- * What a reconcile pass refused to write, so callers can report it.
- *
- * `refresh` used to return void, so a resource agents-cli declined to write was
- * visible only on the interactive path — `agents sync --yes` and the
- * `--device all` fan-out reported a clean sync (RUSH-2700).
- */
 interface RefreshResult {
-    /** User-facing sentences, one per refused resource, prefixed with the agent. */
     declined: string[];
-    /**
-     * The exact (agent, version) pairs this refresh reconciled — the set a
-     * post-reconcile verification must re-check for residual drift, so it never
-     * flags a version the reconcile never targeted (PHNX-3186).
-     */
     reconciled: Array<{
         agent: AgentId;
         version: string;

package/dist/lib/refresh.js

@@ -1,13 +1,3 @@
-/**
- * Materialization helpers — install manifest CLIs, register MCP servers,
- * sync resources into installed version homes, register hooks, add shims to
- * PATH, prompt for missing default versions, install declared host-CLIs.
- *
- * The reconcile stage behind `agents sync` (the umbrella `--local` path calls
- * this; see sync-umbrella.ts) and any other caller that needs to re-derive local
- * state from declared configuration. Does NOT do any git operations — that lives
- * in `agents repo pull`.
- */
 import * as fs from 'fs';
 import * as path from 'path';
 import chalk from 'chalk';
@@ -22,12 +12,6 @@ import { listCliStatus, installCli, describeMethod, describeCheck, selectInstall
 import { ensureShimCurrent, ensureGhOverloadShim, isShimsInPath, addShimsToPath, getPathSetupInstructions, switchConfigSymlink, switchHomeFileSymlinks, } from './installations/shims.js';
 import { parseHookManifest, registerHooksToSettings } from './hooks/install.js';
 import { isPromptCancelled } from './format.js';
-/**
- * Old repo layout stored promptcuts under claude/promptcuts.yaml (agent-scoped).
- * The new layout is `~/.agents/.system/promptcuts.yaml` at the repo root — the
- * hook reads from a fixed path so it survives version upgrades. If the root
- * file doesn't exist yet but an agent-scoped one does, hoist the first one found.
- */
 function migratePromptcutsToRoot(agentsDir, quiet = false) {
     const rootPath = path.join(agentsDir, 'promptcuts.yaml');
     if (fs.existsSync(rootPath))
@@ -43,7 +27,6 @@ function migratePromptcutsToRoot(agentsDir, quiet = false) {
                 return;
             }
             catch {
-                // Best-effort migration; hook still works if the user moves it manually.
             }
         }
     }
@@ -51,11 +34,8 @@ function migratePromptcutsToRoot(agentsDir, quiet = false) {
 export async function refresh(options = {}) {
     const { agentFilter, skipPrompts = false, skipClis = false, quiet = false, selection: requestedSelection, allowExecSurfaces = false, } = options;
     const agentsDir = getUserAgentsDir();
-    // Gate every human progress line so --json / fleet fan-out can parse stdout.
     const log = (...args) => { if (!quiet)
         console.log(...args); };
-    // Resources this pass refused to write, surfaced by the caller. An empty
-    // synced list cannot also mean "declined and here is why" (RUSH-2700).
     const declined = [];
     const reconciled = [];
     if (!requestedSelection)
@@ -64,7 +44,6 @@ export async function refresh(options = {}) {
     if (!manifest) {
         log(chalk.gray(`No ${MANIFEST_FILENAME} found`));
     }
-    // 1. Install/upgrade CLI versions from agents.yaml
     if (!skipClis && manifest?.agents) {
         log(chalk.bold('\nCLI Versions:\n'));
         const cliAgents = Object.keys(manifest.agents);
@@ -93,7 +72,6 @@ export async function refresh(options = {}) {
             }
         }
     }
-    // 2. Register MCP servers
     if ((!requestedSelection || requestedSelection.mcp) && manifest?.mcp && Object.keys(manifest.mcp).length > 0) {
         log(chalk.bold('\nMCP Servers:\n'));
         for (const [name, config] of Object.entries(manifest.mcp)) {
@@ -121,11 +99,6 @@ export async function refresh(options = {}) {
             }
         }
     }
-    // 3. Sync resources into version homes.
-    // Unattended (`skipPrompts` / `agents sync --yes --local`) and explicit
-    // resource selectors: every installed version. Otherwise non-default homes
-    // keep stale resources after a system update or named plugin sync.
-    // Interactive full reconcile: default only.
     const cliStates = await getAllCliStates();
     const agentsToSync = agentFilter ? [agentFilter] : MANAGED_AGENT_IDS;
     const available = getAvailableResources();
@@ -141,10 +114,6 @@ export async function refresh(options = {}) {
             : [defaultVer];
         if (versionsToSync.length === 0)
             continue;
-        // Interactive-only: getActuallySyncedResources walks every skill tree with
-        // content compares (~1s/agent on a full install). The unattended path
-        // (`skipPrompts` / `agents sync --yes`) never reads these — it always
-        // force-full-syncs — so skip the scan entirely (RUSH-2320 #1).
         let actuallySynced;
         let newResources;
         let hasAnySynced = false;
@@ -186,8 +155,6 @@ export async function refresh(options = {}) {
             if (forceFullSync || (selection && Object.keys(selection).length > 0)) {
                 const kinds = new Set();
                 for (const ver of versionsToSync) {
-                    // Pass the already-built `available` so each version does not re-scan
-                    // resource trees (RUSH-2320 #5).
                     const syncResult = syncResourcesToVersion(agentId, ver, selection, {
                         available,
                         allowExecSurfaces,
@@ -229,7 +196,6 @@ export async function refresh(options = {}) {
             }
         }
     }
-    // 4. Register hooks as lifecycle events (same version set as resource sync)
     const hookManifest = requestedSelection ? {} : parseHookManifest();
     if (Object.keys(hookManifest).length > 0) {
         let hookRegistered = 0;
@@ -255,15 +221,11 @@ export async function refresh(options = {}) {
             log(chalk.green(`\nRegistered ${hookRegistered} hook lifecycle event(s)`));
         }
     }
-    // 5. Auto-add shims to PATH
-    // Refresh the gh overload shim so `gh pr checks` escapes the GraphQL rate limit
-    // for every user, transparently (PHNX-3501). Idempotent; POSIX-only in v1.
     if (!requestedSelection) {
         try {
             ensureGhOverloadShim();
         }
         catch {
-            // Never let a shim-write hiccup break sync — real gh stays fine without it.
         }
         if (!isShimsInPath()) {
             const pathResult = addShimsToPath();
@@ -277,7 +239,6 @@ export async function refresh(options = {}) {
             }
         }
     }
-    // 6. Prompt for missing default versions
     if (!skipPrompts && !requestedSelection) {
         const agentsNeedingDefault = [];
         for (const agentId of agentsToSync) {
@@ -288,9 +249,6 @@ export async function refresh(options = {}) {
         }
         const selectedVersions = [];
         for (const agentId of agentsNeedingDefault) {
-            // Isolated copies are not default-eligible — `agents use` refuses them and
-            // setting one here would also switch the config symlink, pointing the user's
-            // real ~/.<agent> at an isolated home. Keep them out of the picker entirely.
             const versions = listInstalledVersions(agentId).filter((v) => !isVersionIsolated(agentId, v));
             if (versions.length === 0)
                 continue;
@@ -324,7 +282,6 @@ export async function refresh(options = {}) {
             log(chalk.green(`Set ${agentLabel(agent.id)}@${version} as default`));
         }
     }
-    // 7. Install declared host-CLIs
     if (!requestedSelection) {
         try {
             const { statuses, errors } = listCliStatus(process.cwd());
@@ -376,8 +333,6 @@ export async function refresh(options = {}) {
             }
         }
     }
-    // A resource agents-cli refused to write is reported, never swallowed —
-    // an empty synced list on its own reads as "nothing to do" (RUSH-2700).
     if (declined.length > 0) {
         log(chalk.yellow('Not written:'));
         for (const reason of declined)

package/dist/lib/registry.d.ts

@@ -1,50 +1,23 @@
-/**
- * Package registry client -- search, resolve, and install from remote registries.
- *
- * Queries the MCP registry (registry.modelcontextprotocol.io) and future skill
- * registries to find packages, then resolves them into installable entries
- * with transport, runtime, and argument metadata.
- */
 import type { RegistryType, RegistryConfig, McpServerEntry, SkillEntry, RegistrySearchResult, ResolvedPackage } from './types.js';
 export declare function validatedNpmSpec(spec: string): string;
 export declare function validatedPyPISpec(spec: string): string;
-/** Get all registries of a given type, merging defaults with user overrides. */
 export declare function getRegistries(type: RegistryType): Record<string, RegistryConfig>;
-/** Get only the enabled registries of a given type. */
 export declare function getEnabledRegistries(type: RegistryType): Array<{
     name: string;
     config: RegistryConfig;
 }>;
-/** Add or update a registry configuration in agents.yaml. */
 export declare function setRegistry(type: RegistryType, name: string, config: Partial<RegistryConfig>): void;
-/** Remove a user-configured or seeded registry. Returns false if it did not exist. */
 export declare function removeRegistry(type: RegistryType, name: string): boolean;
-/** Search MCP registries for servers matching a query string. */
 export declare function searchMcpRegistries(query: string, options?: {
     registry?: string;
     limit?: number;
 }): Promise<RegistrySearchResult[]>;
-/**
- * Convert an MCP server registry entry into an install spec suitable for
- * writing into `manifest.mcp`. Returns `null` if the entry has no package we
- * know how to launch (e.g. only remote endpoints, which the current manifest
- * shape supports via `url`+`transport: 'http'` but isn't yet wired to the
- * registry's `remotes` field).
- *
- * Supported package shapes:
- *   - npm / runtime=node      → `npx -y <name>`
- *   - pypi / runtime=python   → `uvx <name>`
- *   - runtime=docker          → `docker run --rm -i <name>`
- *   - runtime=binary          → `<name>` (assumed to be on PATH)
- */
 export declare function mcpEntryToInstallSpec(entry: McpServerEntry): {
     command?: string;
     url?: string;
     transport: 'stdio' | 'http';
 } | null;
-/** Look up detailed info for an MCP server by exact name. */
 export declare function getMcpServerInfo(serverName: string, registryName?: string): Promise<McpServerEntry | null>;
-/** One row of a skill index document. */
 export interface SkillIndexEntry {
     name: string;
     description?: string;
@@ -56,74 +29,36 @@ export interface SkillIndexEntry {
     tags?: string[];
     author?: string;
     installs?: number;
-    /** Lowercase hex sha256 of the skill's SKILL.md supplied by the registry index. */
     sha256?: string;
 }
-/** Raw shape of the skill index document served by Hermes and compatible registries. */
 export interface SkillIndexDocument {
     version?: number;
     generated_at?: string;
     skill_count?: number;
     skills: SkillIndexEntry[];
 }
-/** Map a raw skill-index row into the canonical SkillEntry shape. */
 export declare function normalizeSkillEntry(raw: SkillIndexEntry): SkillEntry;
-/** Search skill registries for entries matching a query string. */
 export declare function searchSkillRegistries(query: string, options?: {
     registry?: string;
     limit?: number;
 }): Promise<RegistrySearchResult[]>;
-/** Look up a skill by identifier (or name) across enabled skill registries. */
 export declare function getSkillEntry(skillIdentifier: string, registryName?: string): Promise<SkillEntry | null>;
-/** Derive a cloneable git source from a skill entry's repo/source metadata. */
 export declare function skillEntryToGitSource(entry: SkillEntry): string | null;
-/** Unified search across all enabled registries of the specified type(s). */
 export declare function search(query: string, options?: {
     type?: RegistryType;
     registry?: string;
     limit?: number;
 }): Promise<RegistrySearchResult[]>;
-/** Parse a package identifier into its type (mcp, skill, git) and name. */
 export declare function parsePackageIdentifier(identifier: string): {
     type: RegistryType | 'git' | 'plugin' | 'unknown';
     name: string;
 };
-/** Resolve a package identifier to an installable package with source metadata. */
 export declare function resolvePackage(identifier: string): Promise<ResolvedPackage | null>;
-/** Lowercase hex sha256 of a file's bytes. Small files only (SKILL.md). */
 export declare function sha256OfFile(file: string): string;
-/**
- * Parse an 'owner/repo' slug from a git remote URL (https or scp-style ssh) or
- * a filesystem-path remote whose path is slug-shaped (`…/github.com/owner/repo`).
- * Returns null if the remote is not a recognizable GitHub-style shape.
- *
- * Backslashes are folded to forward slashes first: a real git URL never
- * contains one, but a local-path remote on Windows does
- * (`C:\…\github.com\org\a.git`), and without the fold the same remote that
- * parses as `org/a` on POSIX returns null on win32 — which made the
- * projects-pull slug verification fail closed as `blocked` there (RUSH-2694).
- */
 export declare function parseOwnerRepoFromRemote(remoteUrl: string): string | null;
-/**
- * Walk a repo's skills/ and build a flat {@link SkillIndexDocument}. Each entry
- * carries the sha256 of its SKILL.md so install can verify integrity after
- * cloning.
- *
- * `repoSlug` is the 'owner/repo' the skills are published under, written into
- * each entry's `repo` field so {@link skillEntryToGitSource} resolves it to
- * `gh:owner/repo`. `identifier` is set to the skill's directory name so
- * `agents install skill:<name>` resolves against this index.
- */
 export declare function buildSkillIndex(repoPath: string, repoSlug: string, opts?: {
     generatedAt?: string;
 }): SkillIndexDocument;
-/**
- * Verify a cloned skill's SKILL.md against the sha256 recorded in its registry
- * entry. Returns ok when the entry carries no sha256 — indexes published before
- * integrity hashes (or by third parties) simply skip the check. Returns an
- * error when the file is missing or its hash differs, so install can abort
- * rather than silently trusting a tampered artifact.
- */
 export declare function verifySkillIntegrity(repoPath: string, entry: Pick<SkillEntry, 'name' | 'path' | 'sha256'>): {
     ok: boolean;
     error?: string;